Nowadays, I think most security related people know the importance of random numbers in cryptography. We need to generate IVs, session keys, challenges, tokens, etc. that make our crypto systems secure, if the PRNG is predictable the whole system is shattered (right Sony? btw, remember the “Crypto Tales” talk? check the slide 29 xD)

PRNGs… that’s what made me think about crypto03 for the contest. I hate all those crypto levels which are just a matter of luck, iluminated ideas or non realistic scenarios, so I tried to avoid all of those and show something new.

Here, a file was encrypted with a key obtained from the first 128 bits of a PRNG and as a starting point you had a small stream of bits from the PRNG. The purpose was to break the PRNG to know every output you could obtain, then generate a dictionary of possible keys and crack the encryption. The file was encrypted with 128 bit AES, let’s say non-breakable, but with that PRNG you only got ~32k possible keys, and that’s very very broken.

Unfortunately, this ended in a big #doublefacepalm and from here I apologize, specially to Int3pids and Painsec, who did great at the contest and to Security By Default. Apparently I skipped the lesson where they teach you that 1000 in binary is 8 and not 4, so after doing the hard part I encrypted the file with the wrong key “F76AB499B1DDBD2DAC6D90923E3457A0″ instead of the correct one “F76AB499B1DDBD2DAC6D90923E3857A0″.

Yeah, I know, I deserve a …

Anyways, this post is to explain how to break a LFSR-based PRNG.  Well, a LFSR is a shift register where some of the output bits are used as feedback with a linear combination of them. This is really easy to implement both in hardware and in software and probably that’s why they were (still are) so extended.

A LFSR will have a finite number of states and after that the output will repeat itself. Depending on the feedback the output length will be maximized or decreased. The feedback is a linear combination of the output bits so you can represent it as a polynomial.

Disclaimer: the latex plugin is not working properly, I’m sorry for your eyes

For example, a 4 bit LFSR. Input: s3, s2, s1, s0, feedback: C(D) = D^4+D and output: s0, s1, s2, s3, s4, s5, s6, …. Then the connection polynomial is c(x) = x^4 + x + 1 and the new bits will be obtained xor’ing the shift register contents with the bits specified in the polynomial.

I implemented everything on Matlab.

function k = lfsr(c,s0,n);
 
%
% Use:
% k = lfsr(c,s0,n)
%
% Generates a sequence of n bits produced by a shift register LFSR
% with connection polynomial c and an initial state s0.
%
% Input variables:
% c: Coefficients of the connection polynomial
% $c(D)=1+c_1 D + c_2 D^2 + ... + c_L D^L$:
% [1 c_1 c_2 ... c_L ]
% s0: Initial state [s(L-1) s(L-2) ... s(0)]
% n: Length of the sequence we aim to generate.
% Output variables:
% k: Generated sequence
 
if (nargin ~= 3), %number input arguments
    error('The number of input parameters must be 3');
end
if (nargout ~= 1),
    error('The number of output parameters must be 1');
end
if ( (length(c)-1) ~= length(s0) )
    error('The sizes of the polynomial and the initial stated do not agree');
end
 
k = zeros(1,n);
reg = zeros(1,length(s0));
statelen = length(s0);
reg = s0;
mask = c([2:end]); % forget about "+1" value
 
for i=1:n
    k(i) = reg(statelen); % output current bit
    feedback = 0;
    for j=1:statelen
        if ( mask(j) == 1 )
            feedback = xor(feedback,reg(j));
        end
    end
    reg = reg([ end 1:end-1]);
    reg(1) = feedback;
end

Let’s try it:

>> stream = lfsr([1 1 0 0 1], [1 1 1 1], 20)
 
stream =
 
     1     1     1     1     0     1     0     1     1     0     0     1     0     0     0     1     1     1     1     0

An n-LFSR can have 2^n – 1 inner states and under certain conditions a maximal period of 2^n – 1 (if the connection polynomial is primitive modulo 2). They pass statistical tests for randomness so they are good for simulations but as we will now see they’re quite broken.

Primitive what? A primitive polynomial of degree n is an irreducible polynomial dividing x^(2^n – 1) + 1, not dividing x^d + 1 for every d dividing 2^n – 1. Before you run away, let’s have an example:

x^4 + x^3 + 1 is primitive because

• is irreducible in Z2
• divides to x^(2^4 – 1) + 1:
  • x^(2^4 – 1) + 1 = (x^4 + x^3 + 1) * (x^11 – x^10 + x^9 – x^8 + x^6 + x^4 – x^3 – 1)
• do not divides neither x^5 + 1 nor x^3 + 1

Another nice thing is that primitive polynomials are sparse so we can do fast calculations on computers.

So, now we want to synthesize the feedback formula given an output. The first option is trying to solve a linear system, have on mind that each inner state corresponds to the next n outputs, so from 2n consecutive output bits we can determine the feedback function.

If you don’t have enough bits to build the equations you would have to bruteforce dependent variables in the linear system.

Other attack (the one I used) is the Berlekamp-Massey algorithm that given a sequence of bits allows you to find the linear complexity and the feedback function of an LFSR.

THE BERLEKAMP-MASSEY ALGORITHM

You can read about it on wikipedia although I implemented it from other notes. You can find multiples references in math/crypto papers.

function [L,C] = berlekamp(S)
 
%
% Use:
% function [L,C]=berlekamp(S)
%
% Obtains the connection polynomial and the linear complexity of
% the sequence $S$.
% Remark: the Berlekamp-Massey algorithm do not returns the
% initial state.
%
% Input parameters: S (Sequence of bits)
% Output parameters:
% L (Linear complexity of the sequence)
% C Polynomial with MSB first
 
% Checking
if (nargin ~= 1),
error('The number of input parameters must be 1');
end
if (nargout ~= 2),
error('The number of output parameters must be 2');
end
 
% Initialization
L = 0;
C = 1;
m = -1;
B = 1;
N = 1;
 
n = length(S);
 
% Loop
while ( N <= n)
    % discrepancy
    sumatory = 0;
    for i=1:L
        sumatory = sumatory + C(i)*S(N-i);
    end
    d(N) = rem( (S(N)+sumatory), 2);
 
    if ( d(N) == 0)
        % Linear complexity of S^(N+1) is L
        % not sure if I need to do sthg.
    elseif ( d(N) == 1 )
        T = C;
        % C = C + B*D^(N-m)
        % C and B have to be same size to be added
        % first we pad B wih zeros
        Bpadded = [ B zeros(1,N-1-m) ];
        % lengths
        lenC = length(C);
        lenB = length(Bpadded);
        if ( lenC > lenB )
            % insert zeros in the beginning
            Bpadded = [ zeros(1,lenC-lenB) Bpadded ];
        end
        if ( lenC < lenB )
            % make C longer
            C = [ zeros(1,lenB-lenC) C ];
        end
        % both are equal length so we can add
        C = C + Bpadded;
 
        if ( L <= (N-1)/2 )
            L = N - L;
            m = N - 1;
            B = T;
        end
    end
 
    N = N + 1;
end

Let’s see if it works:

>> [L C] = berlekamp(stream)
 
L =
 
     4
 
C =
 
     1     0     0     1     1

Now let’s use given bits in Crypto03. Depending on the bits stream the algorithm can converge better, so the best option is to start from a long group of ones (just move some bits forward from the beginning as a starting point)

This was the original bit stream from the PRNG:

10100000000000011000000000000010000000000000011111111111111101010101010101001100
11001100111011101110111010010110100101100011011000110111101101111011010110110101
10110010010011011011100011101101101000010110110110000011011011011111101101101101
01011011011011001101101101101110110110110110100100100100100111000111000111010000
10111101001111100101001110101000110001011001111011110010001010010100011110011100
11110101110100010100110100111100111011000101000101101111001111001001010001010001
11001111001111010001010001010011110011110011101011101011101001101001101001110110
00100111010010000111010011100000101100010111111001000011010101110000010011001011
11110001000110101011110000100110010100000111011100111111010010111010101100011010
01100100001001110111000001110100101111110100111001010100111010001100111010011110
11101001110101101001110100110110001011000100100001101111000111110110101111010100
10011010110011100010011011101000011101101001111101001001110101001110001011001110
10000110111010011111011010011101010010011101001100011101001110111101001110100101
00111010011100111010011101000101100010110000110111100100000100101000111111000110
00010101000010000011001111100000010001010111111100001100101010111110111001100101
01101000100011001001111000010001110101111100001011001010111110010001100101011100
00100011001011111000010001101010000011110110011111101011011101010110010010110011
01110001101110110100001001011011000001110010010000001011100011111110010111101010
10001101011001100001001101110111110001001011010100001110010011000001011100010000
00110100001111111011000001010101101111110011001001010100010001110011000011110100
01000001010011110000001100010100000001000011000000001111101111111110101001010101
01100111001100110111010001000100101100001111000110111110101111011010100110101101
10011101100100100010110111000111100100101111010111000110101100101111011001000110
10110111000010011011010000011101101100000010110110111111100100100101010111000111
00110010111101000100011010110000111101100100000101001000111111001110000101010001
01111100110000110101000100000100110000111111000100000101010000111111001100000101
01000100000011001111000000010001010000000011110011111111101011101010101001101001
10011000100111011101111000101101001010000110110001100000100100001000000111000001
11111101000000101010110000000110011011111111011101101010101101

>> [L C] = berlekamp(prngData)
 
L =
 
    15
 
C =
 
     1     0     0     0     0     0     0     0     0     0     0     0     0     0     1     1

I tried with different subsets of the bits from the PRNG and sometimes I had some curious results.

>> [L C] = berlekamp(prngData2)
 
L =
 
    15
 
C =
 
     1     2     0     0     0     0     0     0     0     0     0     0     0     0     1     1

That “two” could turn into a “zero” or a “one”, means it still was iterating so we could only say it could be x^15+x^14+x+1 or x^15+x+1. But if we are speaking about a cryptographic use we could almost discard the first one because is not primitive, so might not be of maximal period, which is a nice feature in this case.

Of course, there’s a shortcut to solve the challenge, once you decided it was LFSR-based you could take a list of primitive polynomials in modulo 2, try them all and check which one overlaps with the given bits xDD

Once we had the feedback polynomial we still didn’t know the seed but it doesn’t matter. We could generate all 2^15 – 1 keys and try them all.

This was the correct key:

>> key = lfsr([1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1], [1 0 1 0 1 1 0 1 1 1 0 1 1 1 1], 128);
>> fprintf('%d',key)
11110111011010101011010010011001101100011101110110111101001011011010110001101101100100001001001000111110001110000101011110100000

Painsec it seems they just guessed the feedback by checking the stream by hand and Int3pids did a nice script that completed the LFSR sequence although I’m not sure if it would work with any feedback.

To encrypt/decrypt the file I used OpenSSL, the file was a GIF with the flag “aLFSRist00WeaKz” written on it.
That’s all!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Crypto04 challenge write-up from Campus Party Europe
• Campus Party 2010 – Wargame Leftovers winner!

Uri from Int3pids won the challenge. Congratulations! Eloi, dreyer, earada, kachakil and roman_soft did a great job too, thanks to all the participants.

Now you can find online the solution of Crypto02

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Crypto04 challenge write-up from Campus Party Europe
• Breaking LFSR-based pseudo-random number generators
• Campus Party 2010 – Wargame Leftovers

Go, get them and have fun! First to solve both gets a $30 gift card for Amazon. All the info available at

http://vierito.es/cp2010wargame/

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Crypto04 challenge write-up from Campus Party Europe
• Breaking LFSR-based pseudo-random number generators
• [Campus Party 09] Sistemas de Detección de Intrusos

El Maligno me lió para dar una charla en el III Curso de Verano de Seguridad en Valencia. El curso ha estado genial, tanto las ponencias como la gente que acudió, sin duda una gran oportunidad para pasar un buen rato con conocidos y nuevas caras.

Mi charla la quise enfocar como una recopilación de fallos comunes (algunos de ellos famosos) cuando nos toca tratar con criptografía. Es un tema un poco denso así que para darle un toque más curioso y divertido en la parte final incluí puntos decisivos a la hora de implementar criptografía en dispositivos embebidos en los que, debido a factores como el side channel, tenemos que tener en cuenta todo tipo de nuevas medidas.

Gracias a Eloi y Bea por echarme una mano

Aquí os dejo la presentación de Historias de la cripta

Si tenéis dudas o preguntas podéis dejar comentarios aquí o usar twitter con el tag #cripta.

Keep hacking!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Ganadores del reto de criptografía
• Cuando no se tiene cuidado con la criptografía…
• Conferencia sobre criptografía y reto

Así que aquí va una lista de los mejores plugins que te ayudarán tu tarea de pwning. Gracias a todos los que me habéis recomendable alguno de ellos.

• Hex-Rays:  Creo que este era evidente. Uno de los mayores atractivos de IDA Pro.
• IDAPython: para poder manejar IDA desde scripts en python
• Turbodiff: para comparar cambios en binarios, comunmente llamado diffing. Otras opciones con el mismo propósito con Darungrim, Patchdiff y BinDiff
• Adobe Flash Disassembler: el nombre habla por sí mismo
• IDADWARF: para importar símbolos DWARF de binarios ELF. Nos facilita así conocer nombres y tipos, arregla algunos tipos y renombra variables y registros para una comprensión más sencilla. Vamos la pareja perfecta con Hex-Rays cuando es un binario de este tipo.
• Findcrypt: útil para reconocer algoritmos de cifrado, funciones hash y algoritmos de compresión usados dentro del binario. Está claro que algunos son fácilmente reconocibles según las pasadas que den u otras características pero no esta nada mal ahorrarte un buen rato intentando descubrir qué algoritmo es. Este plugin intenta buscar constantes típicas usadas en los algoritmos, ya sea en las famosas S-Boxes, como inicialización u otros.
  [Link to FindCrypt2]
• IDAStealth: para poder evitar y manejar las técnicas anti-debug más comunes
• COM Helper: busca GUIDs
• mIDA: extra las interfaces RPC y reconstruye su IDL
• ms_rtti: información de los Run-time Type Information para binarios C++
• PDB: proporciona información extra sobre los símbolos en binarios de Windows.
• Importar infomación de MSDN: podéis ver como hacerlo en este post de Zynamics, quizá incluso agobiante tanta información pero útil si vas perdido.
• Class Informer: más de lo mismo, más información sobre vftables, RTTI y RTCI
• BinNavi: para visualizar la estructura de un programa, ver el camino que sigue una ejecución, ver como llegar a ciertos puntos del código, etc.
• MyNav: el hermano pequeño pero de código libre de BinNavi. Se publicará en julio, mientras podréis ver una muestra en este post. Promete mucho

Además, en breve tendremos hoy 3 de junio ha salido una suculenta nueva característica que será el soporte para decompilación para ARM, como se nota que esta arquitectura está creciendo mucho

Seguro que hay algun plugin que usas de normal y no está en esta lista así que espero vuestros comentarios.

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• 25C3: Nothing to Hide

Hey there! I usually write in spanish here but as the attendance at Campus Party Europe was pretty international I’ll do this one in english so anyone can understand it.

All the information to try the challenge is at Eloi’s blog since he released it as challenge a couple of days ago. Before continuing I guess you either have played in the hacking contest at Campus Party Europe or already have read that post, if not… you are being late!

So, we receive 3 files: an AES encrypted file, a  public key file and a readme with some instructions and data.

From the readme, this are some hints to understand what’s going on here:

• It uses a cryptographic device that contains a 1024 bit modular exponentiation accelerator
• A pair of RSA signatures over the same data, one of these signatures contains a fault injection

From those hints we get that it is actually using the RSA-CRT algorithm, which is a RSA variation to reduce computational costs using the Chinese Remainder Theorem. The point is that instead of using the 2048 bit modular exponentation it splits them into two modular operations, aproximately half the size, make the calculations and then recombine the results as needed to obtain the regular RSA result. But here’s the trick, if we inject a fault in one of these two exponentiations, via power glitching for example, there’s a way to recover the private RSA key. The use of RSA-CRT is common in embedded devices such as smart cards, mainly because of the hardware limitations. You can read a post about it at Eloi’s blog, it’s in spanish though: RSA-CRT Fault Injection.

RSA signs a message doing:

• s = m^d (mod n)

RSA-CRT does:

• s1 = m^dq (mod q)
• s2 = m^dp (mod p)
• s = a*s1 + b*s2  (mod n) = m^d (mod n)
• a being congruent to one modulo p and zero modulo q
• b being congruent to zero modulo p and one modulo q

Using the faulty signatures:

• s – s’ = a*s1 – a*s1′ will be congruent to zero modulo q
• s – s’ = b*s2 – b*s2′ will not be congruent to zero modulo p

Then if we calculate the greatest common divisor (using the Euclidean algorithm for example) between c-c’ and n ¡we will obtain the factor q! because c-c’ is multiple of q but not p. Then with p = n / q we will have both prime factors used in RSA

Now we have to implement the attack, we need to deal with really big integers so I first though of using Java and its BigInteger, Matlab or Sage. I do hate Java, Matlab would have been nice, usually it treats big integers as arrays and uses proper algorithms adapted to array calculations but Sage was going to be the easiest and quickest for me.

We have s1, s2 and the encrypted message. First we need to obtain the exponent and the modulus from the public.key file, let’s use openssl:

$ openssl rsa -pubin -text -in public.key
Modulus (2048 bit):
00:e8:52:42:77:0a:66:69:8c:64:49:61:5a:d4:8f:
70:e5:ff:7f:49:ca:45:33:43:7d:85:36:7e:1a:f3:
8f:31:aa:35:94:8e:b3:3f:97:88:f7:16:4a:1d:d5:
c3:87:5b:f8:6b:69:3b:d8:cc:82:e2:cb:cb:d0:1c:
f7:d1:b4:51:ef:67:cb:72:90:fa:79:0e:e1:02:24:
e3:72:5b:37:b6:bc:3d:53:56:da:9d:0f:ba:c1:e0:
6b:b2:6f:f2:43:03:d9:06:d3:c9:66:c8:1b:19:9a:
78:b9:ef:02:2b:0f:b9:28:e5:82:fc:0c:e0:29:57:
f6:b1:64:21:01:f9:2e:83:4a:ab:47:24:9e:e4:08:
c2:91:d3:fc:e8:72:c1:44:69:12:31:37:f4:da:49:
28:00:75:03:36:47:20:69:f4:e2:4b:4a:0e:3e:e5:
15:85:ae:78:68:43:a3:c0:39:61:c2:12:a1:e3:94:
d2:71:e8:26:14:c4:e7:aa:1d:5d:a4:16:01:1f:9b:
40:81:a8:e4:70:65:75:1a:de:de:51:d0:90:97:fb:
8a:41:ac:be:2e:54:5c:b6:d4:04:40:1d:59:16:c3:
f6:86:16:e9:66:79:b3:5f:77:74:a9:e4:42:b1:98:
74:14:b0:22:ee:06:f0:0f:ac:3d:dd:b6:14:19:43:
e5:53
Exponent: 65537 (0x10001)
writing RSA key
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6FJCdwpmaYxkSWFa1I9w
5f9/ScpFM0N9hTZ+GvOPMao1lI6zP5eI9xZKHdXDh1v4a2k72MyC4svL0Bz30bRR
72fLcpD6eQ7hAiTjcls3trw9U1banQ+6weBrsm/yQwPZBtPJZsgbGZp4ue8CKw+5
KOWC/AzgKVf2sWQhAfkug0qrRySe5AjCkdP86HLBRGkSMTf02kkoAHUDNkcgafTi
S0oOPuUVha54aEOjwDlhwhKh45TScegmFMTnqh1dpBYBH5tAgajkcGV1Gt7eUdCQ
l/uKQay+LlRcttQEQB1ZFsP2hhbpZnmzX3d0qeRCsZh0FLAi7gbwD6w93bYUGUPl
UwIDAQAB
-----END PUBLIC KEY-----

To copy the modulus it’s easier from here:

$ openssl rsa -pubin -modulus -in public.key
Modulus=E85242770A66698C6449615AD48F70E5FF7F49CA4533437D85367E1AF38F31AA35948EB33F9788F7164A1DD5C3875BF86B693BD8CC82E2CBCBD01CF7D1B451EF67CB7290FA790EE10224E3725B37B6BC3D5356DA9D0FBAC1E06BB26FF24303D906D3C966C81B199A78B9EF022B0FB928E582FC0CE02957F6B1642101F92E834AAB47249EE408C291D3FCE872C14469123137F4DA492800750336472069F4E24B4A0E3EE51585AE786843A3C03961C212A1E394D271E82614C4E7AA1D5DA416011F9B4081A8E47065751ADEDE51D09097FB8A41ACBE2E545CB6D404401D5916C3F68616E96679B35F7774A9E442B1987414B022EE06F00FAC3DDDB6141943E553
writing RSA key
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6FJCdwpmaYxkSWFa1I9w
5f9/ScpFM0N9hTZ+GvOPMao1lI6zP5eI9xZKHdXDh1v4a2k72MyC4svL0Bz30bRR
72fLcpD6eQ7hAiTjcls3trw9U1banQ+6weBrsm/yQwPZBtPJZsgbGZp4ue8CKw+5
KOWC/AzgKVf2sWQhAfkug0qrRySe5AjCkdP86HLBRGkSMTf02kkoAHUDNkcgafTi
S0oOPuUVha54aEOjwDlhwhKh45TScegmFMTnqh1dpBYBH5tAgajkcGV1Gt7eUdCQ
l/uKQay+LlRcttQEQB1ZFsP2hhbpZnmzX3d0qeRCsZh0FLAi7gbwD6w93bYUGUPl
UwIDAQAB
-----END PUBLIC KEY-----

Now we have the modulus and exponent. So let’s start Sage and apply what we’ve seen before

Load the values:

sage: s1 = 0x3ae81964c8ecf1524b47c42cb0ecd2a3b6768dccd55960d7ff0a998f839b8c312a2cd821c270ae961777dd4dd50aa631fe823a8afd914911adf69c1c6cfda3b3aed01dad372cfdd6e9f63a4cc39e1a455cbfd04dea72bf07c4790d5fec469198ce28113d6d38a7baced9d3c3695ab27cbc5ab434aa8d2b5f53f66a383e079ddaed485d4a2b446e410eafcadbba9f159494c28c4a19fd416dff90f8c141e96d8260f8e6e0901832e31899c48ce0cbdae6a24595a19a01e490c87e7b48860e09006920d8ef7384217358c6db90638d6e8cbc795a091240f24105d8f3b27fe4b98fe9a507e00590b4cded41777b1b8967b0f752231e0e856b8f0132bde30a6e082e
sage: s2 = 0x391e0340e5931a202012572ddacad877e5af3a1d846b70c1e64e3041f9ac0a3c7e8f82621df908eadca44fe777a6b1c799610be829e13ca233982fd268034addb5a79fa19f984631fdf3a61d32fc75ed77176c7a0b719504e804076dca66f10111aa124a7efe743ada75dda2ec53f3c28882a7724928685918261739f960a3648aa3eadc426181aa146a8ba0ff20f1c53de2113e0196af09595dc2ad1a0fe12096ff681f61363044615a7f72edf1f8c6531055e66c1e5f4498434c731d2308fecae46c779379ea3d7d7a5f1c2a0efeb5bc1b8a4af4fb21fce1dae943c27043e86642b3b1e6b889a31e7c4bc01bc2ebae4dc8432344532567d1d3df8b9bcafcbf
sage: encrypted = 0x19303a82cbc50a56dc22f9aafc554da2ea632e33bee1d33c35edb13269ba0fd2fa791744e86eda7fc1cb15433f1232f86a42afcd5470215ccf0d05096ce1b8f075e6dc45df74896345297fcc145a4765aeaea78babaa6441ead3a2e73b37931dc7c07d4e04b7115284c7c04c85a61c7e555194d0f4ee762d47a8aeec2efcd75ee45e3e6a65f876f9a67aa01016f3ce9552d8f0b50cc150c70333aa6ac3a4ac8860d2879cad8439566f0ffda32612cb75dd9c1b456a4e1828582f05932f495452f19d71f300f2f48b8c1f8cde1b1b8d8ada3f6ff506e10d5d18d91d61402bc36756a88196381ff795980eee932a179525264e3a968f0abe9edbe672560c41833a
sage: exponent = 0x10001
sage: modulus = 0xe85242770a66698c6449615ad48f70e5ff7f49ca4533437d85367e1af38f31aa35948eb33f9788f7164a1dd5c3875bf86b693bd8cc82e2cbcbd01cf7d1b451ef67cb7290fa790ee10224e3725b37b6bc3d5356da9d0fbac1e06bb26ff24303d906d3c966c81b199a78b9ef022b0fb928e582fc0ce02957f6b1642101f92e834aab47249ee408c291d3fce872c14469123137f4da492800750336472069f4e24b4a0e3ee51585ae786843a3c03961c212a1e394d271e82614c4e7aa1d5da416011f9b4081a8e47065751adede51d09097fb8a41acbe2e545cb6d404401d5916c3f68616e96679b35f7774a9e442b1987414b022ee06f00fac3dddb6141943e553

Calculate q and p:

sage: q = gcd(s1-s2,modulus)
sage: p = modulus / q

In Sage to work with modular arithmetics you need to declare a group and then use the variables in that group. First let’s calculate the private RSA key

sage: G1 = IntegerModRing(lcm(q-1,p-1))
sage: private_key = G1(exponent)^-1

And finally working in modulo ‘modulus’ make the decryption to get the message:

sage: G2 = IntegerModRing(modulus)
sage: message = G2(encrypted)^G2(private_key)
sage: message
333277202522695828352578908493424296965
sage: hex(333277202522695828352578908493424296965)
'fabadababecafedeadbeef0102030405'

It’s a fabada password! xD We now have the plaintext which is the AES key. Let’s use again openssl to decipher the file. The readme file says it’s AES in ECB mode with a 128 bit key. The key length it’s obvious but if we didn’t know the operation mode we could just try them all.

$ openssl enc -d -aes-128-ecb -in encrypted.aes -out unencrypted.file -K fabadababecafedeadbeef0102030405
$ file unencrypted.file
unencrypted.file: PNG image, 124 x 124, 8-bit/color RGB, non-interlaced

We can see that it worked like a charm: the file it’s a PNG image. The first thing you think when you see a PNG it’s uhmm… a bit of stego? thumbnails? LSB? Well, this one is just a QR Code.

Using any QR decoder (I used http://zxing.org/w/decode.jspx ) we get:

Key: DoubleCheckYourCryptoResults

Which is a funny final password since one of the common protections against fault injection attacks is to double-check all sensitive computations

Congratulations to Eloi for this challenge! I found it one of best I’ve ever done because it has to do with real world attacks and crypto related maths, so it’s not just another cryptic puzzle where mostly you only have to use tools or need a smart guess.

I hope you liked it!

Many thanks also to SecurityByDefault for an excelent wargame and congratulations to the winners:

1. knx
2. FluxReiners
3. aw3a

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Breaking LFSR-based pseudo-random number generators
• Crackeador de hashes MD5 en C y OpenSSL
• 25C3: Nothing to Hide

Más vale tarde que nunca, varias semanas después encuentro un rato para poder escribir este post. El cansancio acumulado hizo que gran parte de la semana siguiente fuera a medio gas y desde entonces he ido hasta arriba de cosas.

¿Qué puedo decir? Sin duda ha sido una gran experiencia, de una vez por todas, poder poner caras a tanta que gente que sólo puedes tratar por e-mail, IRC, foros, twitter o simplemente ni le tratabas y te conformabas con seguirle por internet. Coges a toda esa gente y durante 3 días compartes comidas, cenas y cervezas. Impresionante. Han sido unos días repletos de buen rollo y diversión.

Para la organización mis más sinceras felicitaciones,yo creo que han sacado nota alta y más siendo su primera vez, errores por supuesto que han habido pero como todos sabemos que habrá Rooted CON 2011… no pasa nada, al año que viene más y mejor

Cómo ya sabréis, Eloi y yo fuimos seleccionados con una ponencia sobre Seguridad y Explotación Nativa en Android que parece que gustó bastante, así que no me puedo sentir más orgulloso y realizado. Gracias a todos los estuvísteis ahí a primera hora el último día, como unos campeones. Si alguien se la perdió que no se preocupe porque la presentación os la enlazo ahora y, como ya prometimos en su momento, para descargar también todo el código y ejemplos:

• Seguridad y Explotación Nativa en Android

• Ejemplos y código

En el comprimido podréis encontrar los payloads y los scripts para cada tipo de exploit para metasploit, así como el código del micro-rootkit secuestrador del teclado virtual. De todas formas, en el blog de Eloi (eso sí, en inglés) podréis encontrar más información acerca de ello.

Por ahora casi sólo hemos tenido feedback positivo pero desde aquí os animo a hacernos llegar críticas constructivas, para poder mejorar.

Unas fotillos:

SecurityByDefault cubrió el evento así que podréis encontrar cosillas día a día en su web.

Creo que había ponentes muy muy buenos con charlas que no estaban a la altura de ellos mismos y viceversa, ideas buenas pero que no pudieron llegar al público de la mejor manera. Las que más me gustaron fueron (sin orden en particular):

• Autopsia de una intrusión. A la sombra del chacal, por Pedro Sánchez y Eduardo Abril
• Operación Triunfo Profesional, por Alejandro Ramos.
• Liberando un 0day en la Rooted CON, por Rubén Santamarta.
• Hackproofing Oracle Finantials 11i & R12, por Joxean Koret.
• RootedPanel “Hackers Históricos” con Grupo Apòstols, con Jordi Murgó (savage) y Ramón Martínez (rampa)
• New w32 hooking skills por David Regrera
• Hackers, encerrados en la viñeta por David López López
• iPhone + Botnets = FUN por David Barroso.
• Exploits y mitigaciones: EMET por Fermín J. Serna.

Impresionante también todo el trabajo detrás de Radare2, desarrollado por Sergi Álvarez y Roi Martín. Una de las charlas que me perdí y, que según dicen gustó mucho, fue la de Antonio Ramos, La seguridad como sistema. Factores limitantes y evolución en el tiempo, una pena. Todas las presentaciones se han subido a slideshare.

Por un lado penosa actuación de cierta empresa, además ¿no conocen El Efecto Streisand?

Por otro lado…pobres las azafatas!! se morían un poco de asco xD, bueno de vez en cuando se les escapaban alguna risa. En algún momento que me crucé con una le pregunté ¿no estás harta? a lo cual se le escapó un sincero y directo sí, 2 segundos más tarde se corrigió a sí misma para mantener la compostura: “ay, bueno no, quería decir, ehm, a ver, en realidad no está mal [sonrisa comprometida] he estado en congresos peores”

Eloi y yo decidimos que tocaba atender a las charlas cosa que era totalmente incompatible con el CTF, aún así Amín y Vicent le dedicaron unas cuantas horas, el pobre Amín se quedó a una prueba de quedar tercero y Dani Kachakil consiguió un merecido segundo puesto. Ahora mismo, Dani está en Korea compitiendo junto con los Intr3pids para darles cera a todos en el Codegate 2010.

Fue una lástima que no tuvieramos acceso a internet decente, yo no tenía 3G así que tenía que aprovechar los 30 minutos gratis que me daban en el hotel para revisarme el correo y el twitter. La noche del sábado, ya sin presiones, pudimos disfrutar de una fiesta todos juntos, cosa que se alargó hasta el amanecer sentados con cervezas.

Podréis encontrar otras reseñas del congreso aquí y fotos en el perfil de Flickr. En cuanto estén disponibles todos los videos ya actualizaré.

Lo que tengo muy claro es que acudiré a la Rooted CON 2011, ¡a poder ser como ponente de nuevo! Bueno xD eso será si me dejan o, más difícil aún, si me surge alguna idea buena. Por mi parte ha sido un honor, eso es todo hamijos!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Congreso de Seguridad Rooted CON 2010
• Historias de la cripta
• [Campus Party 08] Diario de a bordo – Parte 2

• Llegar a las manos: Darse leches está mal visto. Meterse mano también.
• Jugárselo a piedra, papel o tijera: si es el otro es japonés estás perdido, vas a perder sí o sí, ellos nacieron con un don para ello. Si no es japonés nada te asegura que vayas a ganar, así que nada, mala opción.
• Jugárselo al tres-en-raya. Esta es la buena.

El tres en raya es un juego sencillo, cuando la gente se pone a jugar se cree que es un juego tonto (que lo es!) y que más o menos, sin considerar empates, el 50% de las partidas las ganarán y el resto las perderán pero no es tan tan sencillo. Así que le sueltas: “Pues ya está! Nos lo jugamos al tres en raya. El primero en ganar será el que tenga la razón, ¿es justo no?” Suelen aceptar.

Vamos a asumir que el juego es empezando con un tablero vacío, que empiezas donde quieras y que cuando ya has puesto las piezas posibles y no ha ganado nadie comienza una partida nueva desde cero.

También vamos a asumir que tú no estás en la parra y que sólo vas a perder si te provocan una situación en la que el contrincante te puede hacer tres en raya de dos maneras simultáneas y no es que se te ha escapado la línea ¬¬. Tú eres cruz, tu víctima será cara.

Cómo no perder

Se supone que el que empieza lleva la voz cantante. Tu contrincante puede empezar en el centro, en una esquina o en un lado. Lo decisivo son las 2 primeras posiciones.

Si él empieza en el centro, ve siempre a la esquina. En caso de que luego su ficha se ponga en línea tu ve de nuevo a una esquina.

Si empieza en una esquina nosotros cogemos el centro.  En caso de que él vuelva a colocar su ficha en línea entonces nosotros nos vamos a una posición que no sea esquina.

Si empieza en un lado cogemos el centro de nuevo. En caso de que él coga un lado contiguo debemos colocar nuestra ficha en la esquina común.

Ahora ya lo tenemos neutralizado.

Cómo intentar ganar

Intentar ganar viene a ser lo mismo pero al revés, con alguna variación más porque él no tiene por qué hacer de su primer movimiento los que yo he hecho antes.  Sólo tienes que esperar a que lleve 3 o 4 partidas y que ponga donde no toca en su segundo movimiento.

Aplicado al primer caso, si empiezas en el centro y él no pone en una esquina está muerto, en el caso de que lo haga tu colocas tu ficha haciendo línea. Ahora si él no se posiciona en una de las dos esquina restantes habrá perdido también.

Si tu contrincante se sabe esto, simplemente jugar será un while(true) hasta que uno de los dos se harte, y entonces, por supuesto, tiene razón el otro

P.S. Aprovecho este post para anunciar que TuXeD se ha comprado un dominio nuevo y pasa de /var/log/TuXeD a Limited Entropy Dot Com. ¡Ya estás actualizando tus feeds y bookmarks!

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

None Found

Cómo se puede leer ya en muchos sitios, este año se celebra un nuevo congreso de seguridad informática en España. Su web es http://www.rootedcon.es y como ellos mismos dicen su objetivo es ofrecer conferencias altamente técnicas y fomentar el conocimiento, no bastante con conocer que existen cosas, hay que saber cómo son y por qué funcionan así

Se va a organizar un wargame tipo Capture The Flag a manos de un Sexy Panda, ¿qué más se puede tener? Además hay una serie de talleres intensivos denominados RootedLabs donde podrás aprender con los mejores sobre: ingeniería inversa, análisis forense, análisis de malware, pentesting, securización de redes inalámbricas y seguridad web (aún quedan plazas libres en los labs si te interesa algún área).

Allá por noviembre me enteré de la existencia el congreso y desde un principio me interesó acudir, pero ¿por qué no algo más? Hablando con TuXeD nos planteamos la posibilidad de enviar algo al Call For Papers, estuvimos unas cuantas semanas dudando pero tiró para adelante…

Unas semanas después (contra todo pronóstico, por lo menos mío) resulta que nos han seleccionado la propuesta, además junto con los primeros ponentes confirmados, cosa que considero un honor más aún. Ya de por sí, ser el último mono iba a ser considerado un éxito 100% por nuestra parte.

Para que os hagáis una idea del personal, esto es lo que hay confirmado por ahora:
http://www.rootedcon.es/rooted-con-2010/ponentes.html

– David Barroso, de S21Sec
- Joxean Koret, de 48bits & Panda Security
- Alfonso Muñoz Muñoz, de la EUI-UPM y colaborador cátedra Applus-UPM.
- Alejandro Ramos “dab”, de SecurityByDefault.
- Antonio Ramos, de S21Sec.
- David Reguera, de Hispasec Sistemas.
- Rubén Santamarta, de ReverseMode & 48bits.
- Chema Alonso, de Informática64

Y TuXeD y yo! No puedo ocultar que estoy emocionado me lo voy a pasar de lo lindo seguro.

Poco a poco se tienen que ir confirmando más ponentes y saldrán los detalles de la conferencias. Esto promete.

Si queréis acudir al evento daos prisa porque debido a la gran acogida pronto colgarán el cartel de todo vendido. Me alegro de que haya surgido una nueva iniciativa así y más aún con precios populares y apostando por gente muy capaz que hay por nuestro país.

Por la mocosfera mucha gente ya se ha hecho eco del evento:
http://www.securitybydefault.com/search/label/rootedcon

Y aquí entrevistas a gente que lo organiza o va a estar danzando por ahí:
http://elladodelmal.blogspot.com/search/label/Entrevistas

Can’t wait!

ACTUALIZACIÓN: Ya empiezan a salir más nombres de ponentes y títulos de las conferencias. Toda la información aquí

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Rooted CON 2010 – All your base are belong to us
• 25C3: Nothing to Hide
• [Campus Party 09] Las crónicas

He cogido el script para generar los tonos del otro post y lo he cambiado para los pitidos duren 40ms (que se resume a cambiar que use 320 muestras en lugar de 1200 para cada pitido o silencio), para que sea un poco más real. El wav que voy a usar será el siguiente: ring.wav

Empezamos, ¿qué necesitamos? Cada pitido estará compuesto por una pareja de tonos así que para saber qué número es deberemos reconocer las dos frecuencias principales que tienen los pitidos, y conocer la frecuencia viene a ser lo mismo que saber el periodo.

Hace un tiempo hice una práctica de Tratamiento Digital de la Señal en la que se hacían cosas de estas, uno de los códigos no es mío, está indicado. El resto los hicimos Rafa y yo en su día.

Aprovechándonos de la Transformada de Fourier:

function [P,f]=periodograma(x,N)
% [P f]=periodograma(x,N)
% Calcula N muestras del periodograma de las muestras en x
% N debe ser > que length(x)
%
% P: Periodograma propiamente
% f frecuencias correspondientes
 
k=0:N-1;
f=k./N;
 
L=length(x);
P=1/L*(fft(x,N)).^2;

Pero lo propio será usar un programa que use ventanas para su propósito:

function [P,f]=periodmodif(x,ventana,N)
% [P ,f]=periodmodif(x,ventana,N)
%
% Calcula N muestras del periodograma modificado de las muestras en x
% N debe ser > que length(x)
%
% P: Periodograma propiamente
% f frecuencias correspondientes
 
if N <= length(x)
   error('N debe ser > que length(x)');
else
   k=0:N-1;
   f=k./N;
 
   L=length(x);
   m=0:L-1;
 
   U=1/L*(sum(ventana(m+1).^2));
   P=1/(L*U)*abs(fft(x.*ventana,N)).^2;
end

Cargamos el fichero ring.wav

>> [x,fs,nbits]= wavread('ring.wav')
>> t=0:1/fs:1/fs*(length(x)-1);
>> plot(x)

Ahora tendremos que calcular de cuanto es nuestra ventana mínima. La separación mínima entre tonos es de 320 muestras (que además en este caso es la misma entre todos los tonos) luego la frecuencia digital será 320 / fs = 320/8000 = 0.04

Y aquí un poco de teoría sobre ventanas gracias a los Apuntes de Pak:

Pero no voy a aburriros con ella así que nos quedaremos en que vamos a usar una ventana tipo Hamming, luego necesitaremos una longitud de ventana L = 4 / resolución = 4 / 0.04 = 100 muestras

Ahora vamos a determinar los dígitos, y para ello vamos a hacer uso de la siguiente función para búscar máximos:

function p=buscapicosu(x,umbral)
%posi_picos=buscapicosu(x,umbral)
% Busca los máximos locales de un vector mayores que un cierto umbral
% umbral se expresa en % respecto al valor máximo del vector.
% Ej. buscapicos(x,60) buscaria los picos mayores o iguales al 60% del
% pico más alto
%
% posi_picos son los indices del vector de entrada correspondientes a los picos.
 
% (C) Antonio Albiol , 2003
 
%Primero descarto los valores menores que el umbral
 
umbral=max(x(:))*umbral/100;
 
x=x.*(x>umbral);
 
%Ahora buscaré los máximos
 
%Primero creo un vector con dos valores muy pequeños en los extremos
xe=[-inf;x(:);-inf];
 
%Ahora calculo la derivada
d1=diff(xe);
ld1=length(d1);
%Ahora busco valores de la derivada de signo diferente consecutivos y que sean máximos
p=find(sign(d1(2:ld1)).*sign(d1(1:(ld1-1)))<0 & sign(d1(1:ld1-1))>0);

Cada pitido y cada silencio dura 320 muestras luego calculamos periodos en esas zonas. Vamos a por el primer dígito, con ventana Hamming de 100 y usando 1024 puntos:

>> [P,f]=periodmodif(x(320:320+99),hamming(100),1024);
>> buscapicosu(abs(P),50)
 
ans =
 
   110
   190
   836
   916

En el espectro digital, de 0 a 1, veremos que las frecuencias se repiten en espejo a partir de 0.5. Luego la frecuencia 110 se corresponde con la 916, igualmente ocurre entre la de 190 y 836, son lo mismo. Así que sólo tenemos que ver a qué corresponden 110 y 190.

Nota a tener en cuenta: en las FFTs (Fast Fourier Transforms) el cálculo se hace mucho más rapido cuando N es una potencia de 2, por eso la elección de hacerlo en 1024 puntos no ha sido del todo al azar.

>> 110/1024*fs
 
ans =
 
  859.3750
 
>> 190/1024*fs
 
ans =
 
  1.4844e+003

Nos vamos a la tablita y vemos con qué 2 valores más cercanos concuerdan 859.375 y 1484.4 Hz. Claramente sería con 852 y 1477 Hz que juntos corresponden con el dígito 9.

Y así con cada uno de los dígitos

Sé que estaría mucho mejor un script que hiciera todo el proceso entero y obtuviera qué número es de la tabla pero últimamente necesito días de 30 horas así os tendréis que conformar con esto. ¿A qué número he llamado?

–
Fuente original en http://vierito.es/wordpress

Similar Posts:

• Llamando por teléfono con Matlab
• Cuestión de optimización