Criptanálise de MD4 Mads Rasmussen

Apresentação em tema: "Criptanálise de MD4 Mads Rasmussen"— Transcrição da apresentação:

1 Criptanálise de MD4 Mads Rasmussen Mads@ime.usp.br

2 Funções de Hash Populares A Família SHA (NSA e NIST)   SHA-0 (colisão descoberta em Agosto 2004)   SHA-1 (segurança reduzida para 2^69 em 2005)   SHA-256 e irmãs A Família MD (RSA Labs – Ronald Rivest)   MD2 (ataque pré-imagem em 2004, colisão reduzida em 2005)   MD4 (colisão descoberta em 1996)   MD5 (colisão descoberta em 2004) Outras Funções   RIPEMD (colisão descoberta em 2004)   HAVAL (colisão descoberta em 2004)   Whirlpool

3 A função MD4 Elaborada pelo Ronald Rivest (RSA)  CRYPTO '90  RFC 1186 (’90) e RFC 1320 (’92) Ainda utilizada  PRNG da Microsoft  Hash de arquivos no eDonkey (P2P)

4 Resultado a ser mostrado Fácil criar pseudo colisões Pseudo colisão facilita uma ataque diferencial Resultado: Colisão de MD4 em poucos minutos Hans Dobbertin, Hans Dobbertin, J. Cryptology (1998) 11: 253–271

5 Função de Hash Supostamente inventado pelo H. P. Luhn da IBM (1953) de acordo com o Knuth Entrada  Mensagem de tamanho arbitrário Saída  Mensagem de tamanho fixo (128 no caso MD4) H : {0,1}* {0,1} 128

6 Segurança de Funções Hash Criptográficas Resistência a Colisões   Deve ser difícil achar M e M’ assim que H(M) = H(M’) Resistência a Segunda Pré-Imagem   Dado um M, deve ser difícil achar M’ assim que H(M) = H(M’) Resistência a Pré-Imagem   Dado um h, deve ser difícil achar M assim que H(M) = h

7 Tipos de Colisões Almost Collision: (quase colisão) 2 mensagens de entrada que entre as saídas da compressão tem diferencia de Hamming (poucos bits diferem) Inner-Almost Collision (quase colisão interna): Colisões ou quase colisões para os valores temporários dos variáveis de cadeia para duas mensagens distintas Pseudo Colisão: Colisão na função de compressão só – não na hash completa Duas mensagens distintas gera o mesmo valor aplicando a função compress. Colisão Colisão na hash completa, duas mensagens gera o mesmo valor hash

8 Função de compressão Ponto central é uma função F de compressão Tamanho do bloco da mensagem 512 bits (MD4) F Bloco de Mensagem M i Hash Intermediário H i Hash Intermediário H i+1

9 Funções de hash Iterados F F F IV M0M0 M1M1 MnMn H0H0 H1H1 H n-1 HnHn Hash

10 Funções hash Iterados

11 O hash MD4 Little endian (arch x86) 4 variáveis de cadeia (chaining vars), A, B,C, D  32 bits cada (4*32 = 128 bits de saída) IV = 67452301x EFCDAB89x 98BADCFEx 10325476x Regra de padding da mensagem para deixar ela múltiplo de 64 bytes inclui o tamanho da mensagem original

12 MD4 compressão Utiliza 3 funções booleanas  F(U,V,W) = (U & V) | (¬U & W) // select  G(U,V,W) = (U & V) | (U & W) & (V & W) // majority  H(U,V,W) = U ^ V ^ W // parity

13 MD4 1.Padding 2. 2.A = 67452301;B = EFCDAB89;C = 98BADCFE;D = 10325476. //IV 3. 3.Processar a mensagem em blocos de 16-palavras (512 bits): for i = 0 to (n/16) - 1 do begin for j = 0 to 15 do X[j] = M[16i + j]; (AA,BB,CC,DD) = (A,B,C,D); Round 1; Round 2; Round 3; A = A + AA; B = B + BB; C = C + CC; D = D + DD; end; 4. 4.Saída é o buffer de 4 variáveis (A,B,C,D).

14 Ataque em detalhes X = (X i ), i < 16 Cria blocos de mensagens X e ~X, onde ~X i = X i, i ≠12 ~ X 12 = X 12 + 1 Resultado do ataque: MD4(X) = MD4(~X)

15 Ataque em detalhes 1.Inner-Almost Collision 2.Ataque Diferencial 3.Acertar valores iniciais corretos

16 Parte I (A i,B i,C i,D i ) = valores dos variáveis de cadeia depois passo i Δi = (A i,B i,C i,D i ) - (~A i,~B i,~C i,~D i ) = (A i - ~A i,B i - ~B i,C i - ~C i,D i - ~D i ) X 12 utilizado em passos 12, 19 e 35 Colisão se Δ35 = 0 Achar uma “quase” colisão para 2 rounds (foca nos passos 12-19) Δ19 = (0,1 <<25, -1 <<5,0), OBS: -1 = 0xFFFF FFFF (little endian) Δ19 = (0,1 <<25, -1 <<5,0), OBS: -1 = 0xFFFF FFFF (little endian) Compress_{12-19} (X) = Compress_{12-19} (~X) com diferência Δ19

17 Compress(X e ~X)_{12-19} Olhando na função de compresão: FF (a, b, c, d, x[12], 3); /* 12 */ ou ~x[12] = x[12]+1 FF (d, a, b, c, x[13], 7); /* 13 */ FF (c, d, a, b, x[14], 11); /* 14 */ FF (b, c, d, a, x[15], 19); /* 15 */ GG (a, b, c, d, x[ 0], 3); /* 16 */ GG (d, a, b, c, x[ 4], 5); /* 17 */ GG (c, d, a, b, x[ 8], 9); /* 18 */ GG (b, c, d, a, x[12], 13); /* 19 */ ou ~x[12] = x[12]+1 F(U,V,W) = (U & V) | (¬U & W) // select G(U,V,W) = (U & V) | (U & W) & (V & W) // majority K1 = 0x 5a827999 A* = A 19, B* = B 19, C* = C 19, D* = D 19, U = A 12, V = D 13, W = C 14, Z = B 15 ~U = ~A 12, ~V = ~D 13, ~W = ~C 14, ~Z = ~B 15 Precisa: ~B* + 1 <<25 = B* e C* + 1 <<5 = ~C* por causa da Δ19

18 StepABCDInputShiftFuncConst 12 U ~U BCDX123F0 13 BCV~VX137F0 14 BW~WV~VX1411F0 15 Z~ZW~WV~VX1519F0 16A*Z~ZW~WV~VX03GK1 17A*Z~ZW~WD*X45GK1 18A*Z~ZC*~C*D*X89GK1 19A*B*~B*C*~C*D*X1213GK1

19 Reduzindo Do (12) obtemos: ~U – U = (A 8 + F(B 11,C 10,D 9 ) + X[12] +1) <<3 – (A 8 + F(B 11,C 10,D 9 ) + X[12]) <<3 ~U >>3 – U >>3 = (A 8 + F(B 11,C 10,D 9 ) + X[12] +1) – (A 8 + F(B 11,C 10,D 9 ) + X[12]) = 1 ~U > x = A > x = A << (32-x) como A é de 32 bits ] Do (13) obtemos: ~V – V = ((D 9 + F(~U, B 11, C 10 ) + x[13]) << 7 ) - ((D 9 + F(U, B 11, C 10 ) + x[13]) << 7 ) ~V >>7 – V >>7 = F(~U, B 11, C 10 ) - F(U, B 11, C 10 ) ~V <<25 – V <<25 = F(~U, B 11, C 10 ) - F(U, B 11, C 10 )

20 Reduzindo Do (19) obtemos: ~B* - B* = (~Z + G(~C*, D*, A*) + x[12] + 1) << 13 ) - (Z + G(C*, D*, A*) + x[12]) << 13 ) ~B* >>13 - B* >>13 = ~Z - Z + G(~C*, D*, A*) - G(C*, D*, A*) + 1 ~B* <<19 - B* <<19 = ~Z - Z + G(~C*, D*, A*) - G(C*, D*, A*) + 1 No final obtemos: (dos passos 12-19) ~U << 29 – U << 29 = 1 ~V <<25 – V <<25 = F(~U, B11, C10) - F(U, B11, C10) ~W <<21 – W <<21 = F(~V, ~U, B11) – F(V,U,B11) ~Z <<13 – Z <<13 = F(~W,~V,~U) - F(W,V,U) U - ~U = G(~Z,~W,~V) – G(Z,W,V) V - ~V = G(A*,~Z,~W) – G(A*,Z,W) W - ~W + ~C* <<23 – C* <<23 = G(D*,A*,~Z) – G(D*,A*,Z) Z - ~Z + ~B* <<19 – B* <<19 – 1 = G(~C*,D*,A*) – G(C*,D*,A*)

21 Quase colisão Uma solução desse sistema leva numa quase colisão X 13 = random X 14 = W <<21 – C 10 – F(V,U,B 11 ) X 15 = Z <<13 – B 11 – F(W,V,U) X 0 = A* <<29 – U – F(Z,W,V) – K 1 X 4 = D* <<27 - V - G(A*,Z,W) – K 1 X 8 = C* <<23 - W – G(C*,A*,Z) – K 1 X 12 = B* <<19 – Z- G(C*,D*,A*) – K 1 D = V <<25 – F(U,B 11,C 10 ) – X 13 A = U <<19 – F(B 11,C 10,D 9 ) – X 12

22 Facilitando Seja ~U = -1 = 0xFFFF FFFF U = 0 B = 0 Então o sistemas de equações ficam reduzidas á: (só reduzindo) – passo 18-24 ~Z = Z - G(~C*,D*,A*) + G(C*,D*,A*) + ~B* <<19 – B* <<19 – 1 ~W = W - G(D*,A*,~Z) + G(D*,A*,Z) + ~C* <<23 – C* <<23 V = W <<21 – ~W <<21 ~V = V - G(A*,~Z,~W) – G(A*,Z,W) C = V <<25 – ~V <<25 Mais G(Z, W, V) = G(~Z, ~W, ~V) = 1 F(~W, ~V, -1) – F(W, V, 0) - ~Z <<13 + Z <<13 = 0

23 Algoritmo I 1.Escolhe A*, B*, C*, D*, Z e W aleatóriamente, calcula ~Z, ~W, V e ~V de acordo com (18-21) e verifica (23) se true goto 2 senão goto 1 2.Valores básicos = os obtidos no 1. (A*, B*, C*, D*, Z e W) troca um bit aleatóriamente nos valores e calcula ~Z, ~W, V e ~V e verifica se (23) ainda vale, se sim verifica se os 4 bits mais direita do (24) = 0 se sim Valores básicos novo Valores básicos novo Repita, se os 8 bits mais direita do (24) = 0, proximo 8, 12, 16 etc Repita, se os 8 bits mais direita do (24) = 0, proximo 8, 12, 16 etc 3.Agora (23) e (24) são satisfeitos Quase Colisão Interna obtida se B = 0 e definindo A,C,D e X i (X i = 0,4,8,12,13,14,15) como em cima Válida se G(B*, C*, D*) = G(~B*, ~C*, D*) (B* = B 19....)

24 Ataque Differencial mod 2 32 Tendo uma quase colisão interna, a probabilidade que isto gera uma colisão para a função de compressão é aproximadamente p=2 -22 Lembrando que X e ~X gera uma colisão se Δ 35 = (0,0,0,0) A diferência entre duas palavras é Δ* = X - ~X (mod 2 32 ), Δ* i é o diferencial Vamos mostrar as diferencias entre Δ* 19 = (0,1 <<25, -1 << 5, 0) e Δ* 35 = (0,0,0,0) seja p{i-1,i} = a probabilidade de Δ i = Δ* i assumindo que Δ i-1 = Δ* i-1 Nota que (por causa da quase colisão interna) Δ 19 = Δ* 19 e Δ 20 = Δ* 20, então p{24,35} = 1 Δ 19 = Δ* 19 e Δ 20 = Δ* 20, então p{24,35} = 1

25 Probabilidades

26 Valor inicial correto Suponha que existe uma quase colisão interna com valor inicial (A,B,C,D) Já fixamos X 0, X 4 e X 8, então escolhe X 1, X 2, X 3 e X 5 aleatóriamente e calcula compress{0,5}(IV, X 0,,,X 5 ) Agora sabemos A 5 =A 4,B 5 =B 4 =B 3, C 5 =C 4 =C 3 =C 2 e D 5 Escolhe X 6,X 7,X 9,X 10 e X 11 assim que compress{6,11}((A 4,B 3,C 2,D 5 ),X 6,,,X 11 )=(A,B,C,D) Nos passos 9,10,11 ver que D 9 =D,C 10 =C e B 11 =B, então escolhe X 9,X 10 e X 11 assim Falta A=A 8 Seja B 7 = -1 e C 6 = A <<29 – A 4 – X 8 A 8 = (A 4 +F(B 7,C 6,D 5 )+X 8 ) <<3 = (A 4 + F(-1,A <<29 -A 4 -X 8,D 5 )+X 8 ) <<3 = (A 4 +A <<29 +A 4 -X 8 +X 8 ) <<3 = A Os valores de C 6 e B 7 podem ser obtidas escolhendo valores apropriados para X 6 e X 7

27 Valor inicial e de 0 a 11 Então obtemos X 6 = -C 2 –F(D 5,A 4,B 3 )+(A <<29 -A 4 -X 8 ) <<21 C 6 = (C 2 +F(D 5,A 4,B 3 )+X 6 ) <<11 =A <<29 -A 4 -X 8 X 7 =-B 3 -F(C 6,D 5,A 4 )-1 B 7 =(B 3 +F(C 6,D 5,A 4 )+X 7 ) <<19 = -1 A 8 =A X 9 =D <<25 -D 5 -F(A,-1,C 6 ) D 9 =(D 5 +F(A,-1,C 6 )+X 9 ) <<7 =D X 10 =C <<21 -C 6 -F(D,A,-1) C 10 =(C 6 +F(D,A,-1)+X 10 ) <<11 =C X 11 =B <<13 +1-F(C,D,A) B 11 =(-1+F(C,D,A)+X 11 ) <<19 =B Assim obtemos que Compress(IV,X 0,,,X 11 )=(A 11,B 11,C 11,D 11 ) = (A 8,B 11,C 10,D 9 )=(A,B,C,D) O valor que leve o IV para o começo do ataque de quase colisão interna

28 Algoritmo Final 1.Calcula a quase colisão interna Calcula A,B,C,D,X 0,X 4,X 8,X 12,X 13,X 14 e X 15 fixando A 19,B 19,C 19,D 19 e ~A 19,~B 19,~C 19,~D 19 para próximo passo 2.Escolhe X 1,X 2,X 3 e X 5 aleatoriamente e calcula (A 5,B 5,C 5,D 5 ) = compress{0,5}(IV,X 0,,,X 5 ) t = A <<29 – A 5 – X 8 X 6 = t <<21 – C 5 – F(D 5,A 5,B 5 ) X 7 = -1 –B 5 –F(t,D 5,A 5 ) X 9 = D <<25 – D 5 – F(A,-1,t) X 10 = C <<21 –t – F(D,A,-1) X 11 = B <<13 + 1 – F(C,D,A) (A 35,B 35,C 35,D 35 ) = compress{20,35}(A 19,B 19,C 19,D 19,X) (~A 35,~B 35,~C 35,~D 35 ) = compress{20,35}(~A 19,~B 19,~C 19,~D 19,~X) Δ35 = (A 35 – ~A 35, B 35 – ~B 35, C 35 – ~C 35, D 35 – ~D 35 ) 3.Se Δ35=(0,0,0,0) nós temos uma colisão, senão goto 2

29 DEMO

30 Crypto ’04 A bad day at the Hash function factory Wang, Feng, Lai, e Yu   Colisões em MD4 em 2 8 operações   Colisões em MD5 em 2 32 operações   Colisões em RipeMD em 2 18 operações   Colisões em HAVAL-128 em 2 7 operações   Colisões em SHA-0 em 2 45 operações

31 Ataques no SHA-0 Crypto ’98: Chabaud e Joux apresenta uma pseudo colisão com complexidade 2 61 (abordagem por força bruta é 2 80 ). 12 de Agosto 2004: Joux, Carribault, Lemuet and Jalby anunciou uma colisão para SHA-0. Uma maquina com 256 processadores de Intel-Itanium2 foi utilizada, o ataque precisava aproximadamente 80 000 horas CPU. A complexidade do ataque era por volta de 2 51. Crypto ’04: Wang, Feng, Lai, e Yu anunciou uma colisão de SHA-0 em 2 40 operações Eurocrypt ’05: Eli Biham, Rafi Chen, Antoine Joux, Patrick Carribault, William Jalby, e Christophe Lemuet, “ “Collisions of SHA-0 and Reduced SHA-1“

32 Novo ataque no SHA Fevereiro 15, 2005: Xiaoyun Wang, Yiqun Lisa Yin, e Hongbo Yu (http://theory.csail.mit.edu/~yiqun/shanote.pdf)http://theory.csail.mit.edu/~yiqun/shanote.pdf Utilizando as técnicas desenvolvidas entre Crypto ’04 e hoje acharem novo ataque nas funções SHA-0 e SHA-1 Colisões no SHA-1 em 2 69 operações (bem menos do ataque por força-bruta de 2 80 operações, 2048 vezes menos) Colisões no SHA-0 em 2 39 operações Colisões no SHA-1 reduzida para 58 iterações em 2 33 operações Schneier estimou que uma maquina custando 25 – 38 milhões de dollars podia fazer os 2 69 cálculos para quebrar o SHA-1 por volta de 56 horas. Último noticia: reduziu ainda mais

33 Perguntas?

34 Explicando a tabela Para verificar que p{34,35} = 1, nota que Δ34 = (0,1,0,0) = Δ34* implica B 35 = B 34 + H(C 34,D 34,A 34 ) + X 12 + K 2 <<15 = (~B 34 + 1) + H(~C 34,~D 34,~A 34 ) + X 12 + K 2 <<15 = ~B 34 + H(~C 34,~D 34,~A 34 ) + (X 12 +1) + K 2 <<15 = ~B 35 P{20,21} é calculado em seguinte maneira Quer mostrar que Pr[Δ21=Δ*21] = Pr[G(A 20,B 20,C 20 ) = G(A 20, ~B 20, ~C 20 )] ~= 1 / 9

35 MD4 Round 1 FF (a, b, c, d, x[ 0], 3); /* 0 */ FF (d, a, b, c, x[ 1], 7); /* 1 */ FF (c, d, a, b, x[ 2], 11); /* 2 */ FF (b, c, d, a, x[ 3], 19); /* 3 */ FF (a, b, c, d, x[ 4], 3); /* 4 */ FF (d, a, b, c, x[ 5], 7); /* 5 */ FF (c, d, a, b, x[ 6], 11); /* 6 */ FF (b, c, d, a, x[ 7], 19);/* 7 */ FF (a, b, c, d, x[ 8], 3); /* 8 */ *FF (d, a, b, c, x[ 9], 7); /* 9 */ *FF (c, d, a, b, x[10], 11); /* 10 */ *FF (b, c, d, a, x[11], 19); /* 11 */ FF (a, b, c, d, x[12], 3); /* 12 */ FF (d, a, b, c, x[13], 7); /* 13 */ FF (c, d, a, b, x[14], 11); /* 14 */ FF (b, c, d, a, x[15], 19); /* 15 */

36 MD4 Round 2 GG (a, b, c, d, x[ 0], 3); /* 16 */ GG (d, a, b, c, x[ 4], 5); /* 17 */ GG (c, d, a, b, x[ 8], 9); /* 18 */ GG (b, c, d, a, x[12], 13); /* 19 */ GG (a, b, c, d, x[ 1], 3); /* 20 */ GG (d, a, b, c, x[ 5], 5); /* 21 */ GG (c, d, a, b, x[ 9], 9); /* 22 */ GG (b, c, d, a, x[13], 13); /* 23 */ GG (a, b, c, d, x[ 2], 3); /* 24 */ GG (d, a, b, c, x[ 6], 5); /* 25 */ GG (c, d, a, b, x[10], 9); /* 26 */ GG (b, c, d, a, x[14], 13); /* 27 */ GG (a, b, c, d, x[ 3], 3); /* 28 */ GG (d, a, b, c, x[ 7], 5); /* 29 */ GG (c, d, a, b, x[11], 9); /* 30 */ GG (b, c, d, a, x[15], 13); /* 31 */

37 MD4 Round 3 HH (a, b, c, d, x[ 0], 3); /* 32 */ HH (d, a, b, c, x[ 8], 9); /* 33 */ HH (c, d, a, b, x[ 4], 11); /* 34 */ HH (b, c, d, a, x[12], 15);/* 35 */ HH (a, b, c, d, x[ 2], 3); /* 36 */ HH (d, a, b, c, x[10], 9); /* 37 */ HH (c, d, a, b, x[ 6], 11); /* 38 */ HH (b, c, d, a, x[14], 15); /* 39 */ HH (a, b, c, d, x[ 1], 3); /* 40 */ HH (d, a, b, c, x[ 9], 9); /* 41 */ HH (c, d, a, b, x[ 5], 11); /* 42 */ HH (b, c, d, a, x[13], 15); /* 43 */ HH (a, b, c, d, x[ 3], 3); /* 44 */ HH (d, a, b, c, x[11], 9); /* 45 */ HH (c, d, a, b, x[ 7], 11); /* 46 */ HH (b, c, d, a, x[15], 15); /* 47 */