RootSecurity

Pessoal, segue mais um post contendo o link para o material da HITBConf (HackintheBox) que acontece todos os anos em Outubro em Dubai. Seguem os Mainstream Medias e blogs contendo informações do evento.

http://conference.hitb.org/hitbsecconf2007kl/

Good Hacking 4 All.

No Vídeo abaixo, o atacante com acesso físico à uma estação executando Windows Vista utiliza um Live-CD com a distribuição BackTrack-3. Montando a partição do sistema, ele acessa o c:\windows\system32\> e modifica o binário Utilman.exe pelo cmd.exe, assim quando o sistema iniciar e o Utilman.exe for solicitado, seja executado um shell para o atacante com privilégios de <SYSTEM>.

Good Hacking 4 All.

SSLdump e um SSL/TLS network protocol analyzer. Ele analisa as conexões TCP na rede onde você está coletando o tráfego e tenta interpretar o tráfego SSL/TLS. Quando ele identifica o tráfego SSL/TLS, ele decodifica os pacotes gravados e depois mostra eles em forma de saída de texto no stdout.

Caso o atacante tenha uma copia dos certificados que estão sendo utilizados na comunicação, o ssldump consegue inclusive descriptografar as conexões e mostrar o data traffic da aplicação.

ssldump 0.9b3

A versão atual do ssldump é a 0.9b3

Download disponível aqui

Documentação Extra aqui.

Exemplos de utilização

ssldump -i le0 port 443

ssldump -i le0 port 443 and host romeo

ssldump -Ad -k ~/server.pem -p foobar -i le0 host romeo

Exemplo de saída

Abaixo segue um exemplo do trace gerado pelo ssldump.

New TCP connection #3: localhost(363  <-> localhost(4433)
3 1  0.0738 (0.073    C>S  Handshake      ClientHello
3 2  0.0743 (0.0004)  S>C  Handshake      ServerHello
3 3  0.0743 (0.0000)  S>C  Handshake      Certificate
3 4  0.0743 (0.0000)  S>C  Handshake      ServerHelloDone
3 5  0.0866 (0.0123)  C>S  Handshake      ClientKeyExchange
3 6  0.0866 (0.0000)  C>S  ChangeCipherSpec
3 7  0.0866 (0.0000)  C>S  Handshake      Finished
3 8  0.0909 (0.0043)  S>C  ChangeCipherSpec
3 9  0.0909 (0.0000)  S>C  Handshake      Finished
3 10 1.8652 (1.7742)  C>S  application_data
3 11 2.7539 (0.8887)  C>S  application_data
3 12 5.1861 (2.4321)  C>S  Alert          warning          close_notify
3    5.1868 (0.0007)  C>S  TCP FIN
 
3    5.1893 (0.0024)  S>C  TCP FIN

Este exemplo usa a flag para decodificação minima. SSLdump tem flags que permitem decodificar todas as mensagens, incluindo o application protocol data.

O SSLdump consegue descriptografar o tráfego entre 2 hosts se as seguintes condições ocorrem:

1. ssldump tem as chaves.
2. Static RSA foi usado.

1 5  0.4129 (0.1983)  C>S  Handshake      ClientKeyExchange
1 6  0.4129 (0.0000)  C>S  ChangeCipherSpec
1 7  0.4129 (0.0000)  C>S  Handshake
1 8  0.5585 (0.1456)  S>C  ChangeCipherSpec
1 9  0.6135 (0.0550)  S>C  Handshake
1 10 2.3121 (1.6986)  C>S  application_data
1 11 2.5336 (0.2214)  C>S  application_data
1 12 2.5545 (0.0209)  S>C  application_data
1 13 2.5592 (0.0046)  S>C  application_data
1 14 2.5592 (0.0000)  S>C  Alert

O SSLdump consegue trabalhar com SSLv1, SSLv2 e SSLv3 e TLS.

Espero que tenham gostado.

Good Hacking 4 All.

Como todos sabem, John the ripper é um dos mais conhecidos e funcionais frameworks para auditoria em hashes e senhas de sistemas, sejam eles Unix ou Windows.

Nativamente o mesmo possui diversas funcionalidades e suporta os Algoritmos de criptografia utilizados na maioria dos sistemas disponibilizados pelo mercado. O john encontra-se atualmente na versão 1.7.2 e pode ser baixado aqui.

John the Ripper é muito rápido e atualmente está disponível para ser utilizado em muitos sabores de Unix (11 são oficialmente suportados, sem contar as diferentes arquiteturas), Windows, DOS, BeOS e OpenVMS.

O Propósito básico do uso do John é detectar passwords fracas que podem causar diversos problemas de segurança à sua infra-estrutura de rede.

Existem diversos patches disponíveis na internet de desenvolvedores que guiados pela necessidade de auditar diversos tipos de hashes diferentes, adicionaram funcionalidades ao John, acrescentando o suporte a muitos outros Hashes de aplicações e sistemas como por exemplo:

* O john mscash patch adiciona suporte para Cached Windows 2000/XP Domain Password Hashes. (mscash).

Abaixo segue uma tabela dos Hashes adicionais que podem ser suportados pelo John the Ripper utilizando alguns Patches que estão disponíveis.

(*) : Estes ciphers não foram testados e provavelmente não funcionam em arquitetura diferente da x86.

Abaixo estão as duas possibilidades de utilização dos patches para adicionar as funcionalidades, fica ao seu critério escolher qual é a forma mais interessante:

• O john bigpatch adiciona suporte para uma grande range de hashes ao John the Ripper. Este patch funciona com o John 1.6.38. Existem vários bugs conhecidos, é recomendado que se utilize a versão abaixo.
• O current tree, é a versão atual que funciona com todos os Hashes. Ele vem com o suporte de todos os Hashes acima e é so compilar e usar :).

Para quem não precisa utilizar nenhum Cipher diferente dos padrões, recomenda-se utilizar o John the Ripper diretamente do site do projeto Openwall.

Good Hacking 4 All.

O Microsoft Windows DNS Stub Resolver (componente no windows responsável pelas queries de upstream para DNS server, e que é utilizado para resolução de endereços na maioria dos programas que o Windows utiliza, ex browsers) envia solicitações DNS previsíveis em relação ao DNS Transaction ID e a porta de origem UDP.

Este tipo de comportamento permite muitos ataques interessantes nos Clients desses DNS, incluindo DNS Cache Poisoning no Cache Local dos Clients (que é gerenciado pelo componente de Stub Resolver), assim como ataques de DNS Drive by Pharmming.

Todos os sistemas Windows Vista, Windows XP SP2, windows 2003 e windows 2000 SP4 são vulneráveis a este tipo de ataque.

No dia 30 de Abril de 2007 a Microsoft foi informada sobre este tipo de falha. Um Bulletin da Microsoft (MS08-020) trata justamente desta questão (pouco tempo né ?).

Existe uma documentação muito interessante e completa sobre este tipo de técnica “Microsoft Windows DNS Stub Resolver Cache Poisoning” que pode ser baixada aqui:

http://www.trusteer.com/docs/windowsresolver.html

O site ExploitSearch.com é uma ferramenta muito útil para pentestes e analistas de segurança porque utiliza a Engine do Google para fazer buscas pela internet por materiais relacionados à determinada vulnerabilidade pesquisada. Em geral ele utiliza referências de links para falhas postadas no site SecurityFocus.com

Good Hacking !

http://exploitsearch.com

Unix-privesc-checker é um script que roda em sistemas Unix (testado no Solaris 9, HPUX 11, vários linuxes, FreeBSD 6.2). Ele tenta encontrar erros de configuração que podem permitir que usuários sem privilégios devidos escalem privilégios para acessar aplicações locais (ex: databases).

Ele é um simples shell script, sendo assim, pode ser facilmente baixado e executado. Ele pode ser executado tanto como normal user quanto como root (óbviamente ele vai dar um resultado melhor quando executado como root porque pode ler mais arquivos). 

Download

unix-privesc-check v1.0 pode ser baixado aqui.

Uso

O Download é gzipado, sendo assim basta dar um gunzip. Faça upload para o server que você deseja fazer o audit / pentest e depois execute:

$ ./unix-privesc-checker > output.txt 

Ele exibe na tela muita tranqueira, sendo assim provavelmente a melhor saida é jogar para um arquivo de saída e procurar pela palavra “WARNING”.  Se você não ver “WARNING” é pq o script não encontrou nada suspeito.

$ ./unix-privesc-check

Starting unix-privesc-check v1.0 ( http://pentestmonkey.net/tools/unix-privesc-check )

This script checks file permissions and other settings that could allow
local users to escalate privileges.

Use of this script is only permitted on systems which you have been granted
legal permission to perform a security assessment of.  Apart from this
condition the GPL v2 applies.

Search the output below for the word ‘WARNING’.  If you don’t see it then
this script didn’t find any problems.

Assuming the OS is: linux

############################################
Checking if external authentication is allowed in /etc/passwd
############################################
No +:… line found in /etc/passwd

############################################
Checking nsswitch.conf for addition authentication methods
############################################
Neither LDAP nor NIS are used for authentication

… lots more output … 

Este script é muito util para administradores que querem manter um nível melhor de segurança assim como para

pentesters que desejam auditar um server unix.

Neste artigo vamos aprender a criar sistemas de Jail em SSH e assim separar recursos a usuários shell de acordo com suas necessidades, criando um ambiente secundário, o que aumenta a segurança na disponibilização de acessos remotos a terceiros.

http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=2125

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 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

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 << | (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);
}