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!

Jaime tenía sus charlas de PHP a las 10 y eso es primerísima hora en la campus, que digo! es una hora inaceptable en la campus! Intentamos llegar a tiempo para poder apoyarle pero durmiendo fuera y acostándonos tarde (más bien cerca del amanecer) era complicado estar antes de las 11. Además se nos juntaba con el suplicio de aparcar y llegar andando desde donde cristo perdió la cruz, al año que viene nos cogemos parking. Este año estuvo a buen precio (no como años anteriores) pero se nos pasó el momento o no nos lo planteamos lo suficiente. El catering a mí me pareció peor que otros años, era otra empresa y encima la CP no dió paella para todos gratis el miércoles como venía siendo tradición… ratas.

A diferencia de otros años, que ya el domingo disponíamos de las acreditaciones y incluso alguna vez teníamos la tienda puesta de antes, esta vez llegábamos de viaje por la tarde y no fue hasta la noche cuando estuvimos acomodados en el puesto. Así cerquita estábamos kuasar, Jaime, Mageles, TuXeD (a partir del jueves), phobeo, Ernesto (encantado de conocerte!), Laura, Ender, akae y unos cuantos más, justo en el medio de la zona de innovación. Repartidos por el resto de la campus estaban muchos más conocidos pero no terminaría nombrándolos, bueno va, a Flexa sí, que se hizo una camiseta super molona con TOOOOODOS nuestros nicks . Sigue leyendo!

Hoy no os traigo un diario detallado, no hay ganas de escribir tanto y además seguro que aburriría, que con el viaje por el Bosnia y Croacia os dejé un misal, por lo menos! El año pasado sí fue un poco más extenso: Campus Party 08 Parte 1 y Campus Party 08 Parte 2

TuXeD dió su charla sobre Smartcards y Side Channel el jueves por la mañana y yo la mía el sábado sobre Sistemas de Detección de Intrusos. Hubo cosas interesantes, hasta vino Jose de Castro a tocar! Este año han subido a youtube bastantes videos con talleres y ponencias.

Un año más hubo concurso de seguridad, esta vez organizado por SecurityByDefault, a los cuales fue un placer conocer en persona. El año pasado participamos TuXeD, Amine y yo juntos y lo ganamos así que este año nos pusimos manos a la obra de nuevo. TuXeD no pudo mirarse nada hasta bien entrado el jueves y el pobre Amín trabajaba en el restaurante de sus padres  (el cual recomiendo) todos los días full-time así que no tenía más remedio conectarse desde el ordenador del restaurante por vnc a su casa y mirarse las cosillas entre que servía un plato y otro xDDD En fin, menudo plan, aún así el equipo funcionó a la perfección y nos pudimos hacer de nuevo con el primer puesto después de mucho empeño Enhorabuena chicos!

El concurso estaba divido en 4 categorías: redes, web, binarios y cripto, para cubrir pruebas de todo tipo. El concurso me gustó mucho, con más nivel que otros años pero… siempre hay un pero jeje, había demasiado fuerza bruta/suerte. Si acertabas a la primera pan comido si no… 2 días perdidos, fue el “fallo/feature” más criticado por los participantes.

Hubo pruebas de todo tipo, algunas muy originales. Por ejemplo, en redes había obtener que orden de nmap había sido ejecutada viendo una captura o crackear la sharedKey del handshake en una autenticación RADIUS, esta prueba me gustó mucho ya que no existía/teníamos herramienta para hacerlo así que hubo que tirar del RFC y programarse un crackeador (en C). En cripto hubo que crackear un certificado pkcs12 y unos mensajes de twitter en cifrados RC4, en binarios en una había que modificar el comportamiento del programa gracias a un LD_PRELOAD y en otra era un buffer overflow en el cual había que volver a los inicios con el señor Aleph One. En una de las pruebas de web una herramienta de Dani Kachakil (nuestro chico maravillas) nos solventó la papeleta y la web4 fue la única prueba que nos quedó por resolver porque nos quedamos atascado en un detalle… no acertar el nombre de un fichero php! Había que saltarse la directiva LIMIT de un apache y luego era un Blind SQL. Lástima. Las últimas horas del concurso fueron muy estresantes,  la noche del viernes Skull y Dade se había puesto manos a la obra hasta el amanecer y se posicionaron segundos, ellos había resuelto la web4 que valía más puntos que la cripto3 así que si resolvían una prueba más nos adelantaban. Estaban a puntito a puntito de obtener la solución de la cripto4 con la que nos adelantaban pero a falta de 15minutos pudimos sacarla nosotros y nos alejamos Maldito LSB! Probamos decenas de herramientas! Joca y cucaracha estuvieron muy muy fuertes en la competición así que felicidades a ellos también.

No me he extendido mucho en las pruebas del wargame pero la gente de SecurityByDefault se han currado unos posts con las soluciones por categorías: Redes, Web, Cripto y Binarios.

Ricardo y Ernesto participaron en un par de competiciones y se las llevaron al agua las 2, si es que están hechos unos crás. Luego Ricardo confesó que había amenazado a los contrincantes para que huyeran despavoridos.

La última noche la pasamos de buen rollo en los jardines de al lado de la CAC, como tiene que ser, tirados en el césped y con spirits!

Os pondría más fotos y más decentes pero no tenía cámara así que sólo tengo las que salen por el flickr de la campus xDD

Otro año más, a poder ser mejor.

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

Similar Posts:

• [Campus Party 08] Diario de a bordo – Parte 2
• [Campus Party 09] Planning
• [Campus Party 08] Diario de a bordo – Parte 1

Apenas queda un mes para que se inicie la Campus Party 2009 en Valencia en su decimotercera edición. Un año más vuelvo al evento colaborando con el área de… un momento… ¿qué han hecho con las áreas?

En 2004 había unas cuantas áreas, todas con su contenido, en los años posteriores empezó una carrera absurda por aumentar ese número y se inventaron unas cuantas sin utilidad ni contenido alguno. Evidentemente el año pasado ya era bastante exagerado… así que la excusa ha venido de perlas. Este año sólo habrá 4 áreas que englobarán a su vez varias de las antiguas.

Frase de la organización: Juntamos lo mejor de cada área para tí.

Realidad: Ponemos cuatro áreas pero sólo un _escenario_ por área, así sólo tenemos que pagar un cuarto de los contenidos de los años anteriores porque no hay tiempo real para meterlos y nos ahorramos una pasta. Cosas de la crisis.

La solución buena de verdad hubiera sido eliminar las áreas que no aportan contenido y reducir así el número, pero no coger y hacer una Campus Party descafeinada (aunque el poco contenido que haya sea bueno, eh?? xDD). Ellos como excusa dicen “menos pero mejor”, yo digo “lo mismo e igual de mejor”, maneras de verlo.

¡Pero vayamos al ajo! ¡Dale al Read More!

Este año el área de Innovación engloba Software Libre, Seguridad y Redes (nueva) y Desarrolladores, bueno va, y CP Lab y Telefonica I+D. Me voy a centrar en las 2 primeras, que son las que quedan en casa. Software Libre viene a ser lo mismo de siempre pero como el plato fuerte de sus actividades estaban relacionadas con la seguridad pues parece que han decidido crear esa zona nueva.

En la zona de Seguridad y Redes:

- TuXeD nos traerá una conferencia sobre SmartCards y RFID. Ataques lógicos y laterales y esas cosas que le gustan. Para saber de qué va el tema no dudéis en echarle un vistazo a su blog.

- Yo daré una conferencia sobre Sistemas de Detección de Intrusos. Un poquito de Snort y alguna otra cosa.

- Rapul repite con la Competición de Criptografía.

- SecurityByDefault se encargará del Concurso de Seguridad. En un principio lo iba a hacer el niño cabezon a.k.a chandra pero bueno, cosas del directo… No tenemos pistas sobre cómo estará enfocado. Además darán una charla sobre Seguridad en Redes Sociales, o al menos eso tengo entendido porque por la web de Campus Party no aclara mucho.

En la zona de Software Libre:

- Jaime continuará con su taller de PHP.

- La gente de eyeOS presentará su proyecto, no sé quién hará la charla pero si queréis echarle un vistazo podéis visitar su web o leer este post que ya escribió Jose Carlos sobre la historia en su blog.

Can’t wait!

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

Similar Posts:

• [Campus Party 08] Taller de antenas y charla sobre servidores
• [Campus Party 09] Las crónicas
• En Berlin!