OpenSesame, hackeando garajes en segundos

OpenSesame es un dispositivo que puede abrir de forma inalámbrica y en segundos casi cualquier puerta de garaje con acceso mediante un pin fijo. Utiliza un nuevo ataque descubierto por Samy Kamkar que se aprovecha del limitado espacio de claves pero que reduce el tiempo para obtener el código en un 95%. Y para llevarlo a cabo sólo necesita un *bonito* juguete de Mattel, un Radica Girltech IM-ME con un efectivo chip RF TI CC1110 sub-GHz y reprogramado con un GoodFET.

Pero centrémonos en el ataque. ¿En qué consiste exactamente? En un equipo inalámbrico normal se utiliza un código de 8 a 12 bits. Si un simple click envía el mismo código 5 veces y cada "bit" tarda 2ms en enviarse con un tiempo de espera de otros 2ms, las cuentas son claras: 12 bits * 2ms transmisión * 2ms espera * 5 veces = 240ms, que es lo que tarda en enviarse una combinación de 12 bits. Entonces, para un ataque de fuerza bruta del espacio de claves de 8, 9, 10, 11 y 12 bits:

(((2 ** 12)*12) + ((2 ** 11)*11) + ((2 ** 10)*10) + ((2 ** 9)*9) + ((2 ** 8)*8)) = 88576 bits

88576 bits * 4ms * 5 retransmisiones = 1771.52 segundos = 29 minutos

Es decir, necesitamos hasta 29 minutos para abrir un garaje con un código de 8 a 12 bits (suponiendo que conocemos el índice de frecuencia y de transmisión, los cuales son bastante comunes.) Si tenemos que intentar algunas frecuencias diferentes y velocidades de transmisión, entonces el tiempo que se necesitamos es un múltiplo de 29 minutos.

Ya veis que el objetivo de este ataque es reducir este tiempo a segundos.

La primera reducción es obvia: quitar la retransmisión que se utiliza para ayudar al receptor a detectar la señal en caso de interferencia. Pero pensemos que no hay interferencias y en lugar de enviar la señal 5 veces la enviamos una única vez:

1771.52s / 5 = 354.304 seconds = ~6 minutes

Simple: así dividimos el tiempo en 5.

La siguiente vuelta de tuerca está también clara. ¿Y si eliminamos el tiempo de espera entre envíos y mandamos cada código back-to-back?. Efectivamente, funciona y reduce el tiempo en transmitir todos los códigos en un 50%! Increíble.

1771.52s / 5 / 2 = 177.152 seconds = ~3 minutes

Pero todavía podemos ir más allá. Aquí es donde hablaríamos del ataque OpenSesame propiamente dicho.

Por ejemplo un código de 3 bits se enviaría inicialmente así:

000---001---010---011---101---111---110---100 (48 bits)

Si quitamos los tiempos de espera se reduciría a la mitad, tal y como comentábamos antes:

000001010011101111110100 (24 bits)

Ahora solapamos (de Bruijn) y reducimos casi otro 62%:

000 011
001 111
010 110
   101 100
0001011100 (10 bits)

Y aquí viene lo bueno. Al mirar los datos que estamos enviando, vemos que se trata de un flujo continuo de bits. Por ejemplo:

     (Código # 1) 000 000 000 000
     (Código # 2) 000 000 000 001
     (Código # 3) 000 000 000 010
     (Código # 4) 000 000 000 011 y así sucesivamente, lo que es:

000000000000000000000001000000000010000000000011

¿Cómo ve el receptor este flujo de bits? Si está utilizando un registro de desplazamiento de bits el garaje se abrirá en cuanto detecte el código correspondiente, ignorando cualquier cantidad de bits antes o después.

Imaginemos que el pin del garaje es 111111000000. Si el receptor utiliza un registro de desplazamiento y le envían 13 bits, "0111111000000", primero nos devolverá pin incorrecto: 011 111 100 000. Pero después seguirá "desplazando" a la izquierda el flujo de bits y enviará 111 111 000 000 ¡correcto!.

Esto significa que con 13 bits hemos probado dos códigos de 12 bits en lugar de enviar un total de 24 bits. ¡Increíble!

Lo más "bonito" es que el garaje no está reseteando por completo cada código intentado, un código de 12 bits también pone a prueba cinco códigos de 8 bits, cuatro códigos de 9 bits, tres 10 códigos de bits, cuatro 11 códigos de bits y, por supuesto, un código de 12 bits! El tiempo les enviamos cada código de 12 bits, todos los códigos de 8-11 bits serán probados simultáneamente.

Ahora, debe haber un algoritmo para producir de manera eficiente cada código posible, con solapamiento (para explotar el registro de desplazamiento) en tan pocos bits como sea posible.
La respuesta la tenía Nicolaas Govert de Bruijn, un matemático holandés que descubrió la llamada secuencia de Bruijn. OpenSesame implementa este algoritmo para producir cada posible secuencia de solapamiento de 8-12 bits en la menor cantidad de tiempo. ¿Qué cantidad de tiempo?

Para probar todas las posibilidades de 8 a 12 bits: ((2 ** 12) + 11) * 4 ms / 2 = 8214ms = 8,214 segundos

Hemos conseguido bajar de 1771 segundos a 8. Incluso la implementación más eficiente con las otras reducciones sin De Bruijn fue en 177 segundos, más de 20 veces más. ¡Impresionante!

A día de hoy los siguientes fabricantes venden productos vulnerables a este ataque:

Nortek / Linear / Multi-Code, producto de ejemplo
NSCD/North Shore Commercial Door, producto de ejemplo

Y los siguientes fabricantes tienen modelos viejos vulnerables pero los modelos que venden ahora ya no son susceptibles a estos ataques (o no se siguen vendiendo):

Chamberlain
Liftmaster
Stanley
Delta-3
Moore-O-Matic

Si estas utilizando un garaje o una puerta que utiliza "códigos fijos" para prevenir este tipo de ataques asegúrate de actualizarte a un sistema con códigos de salto, también llamados "rolling codes", "Intellicode", "Security+", etc. Son mucho más seguros aunque, eso sí, susceptibles a otros ataques.

El código puedes encontrarlo en https://github.com/samyk/opensesame aunque está "brickeado" para que no sea 100% operativo porque su propósito es educativo. Aunque, si eres un experto en RF y microcontroladores podrás corregirlo para que sea funcional...

Fuente: http://samy.pl/opensesame/