Foro Wifi-libre.com

Fuentes :

• Coder la fonction du checksum sur le huitième chiffre des PIN WPS

• Stefan VIEHBOECK, "Brute forcing Wi-Fi Protected Setup - When poor design meets poor implementation.", wordpress.com, version 3, 26.12.2011https://sviehb.files.wordpress.com/2011 … ck_wps.pdf

  Si no habéis leído el PDF de Stefan Viehböck mi consejo del día es : Leerlo. Uno se siente más inteligente después.
Es un texto "histórico" porque desveló al gran publico la presencia de la brecha de seguridad equivocadamente llamada "WiFi Protect Setup" y como efectuar un ataque tipo "brute force" con PIN WPS  permitiendo averiguar en pocas horas las mas complejas y presuntamente seguras llaves WPA.

Recuerdo que el PIN WPS es una cadena de 8 cifras que podemos dividir en 3 partes :

1. Los 4 primeros números, es decir la primera mitad del PIN.
   Es la primera etapa del brute force : se ha de averiguar para obtener M5 y poder pasar al brute force sobre la segunda mitad del PIN.
   Tenemos por lo tanto que realizar un ataque sobre 10⁴ posibilidades (10 000 intentos máximo para obtener la primera mitad)

2. Desde la quinta hasta la séptima cifra (incluidas) del PIN (o sea los dígitos cinco, seis y siete)
   Estos tres números son desconocidos (requieren un brute force). Son 1000 posibilidades (una décima parte del brute force sobre la primera mitad del PIN) 

3. El ultimó dígito, llamado "Checksum WPS" (suma de comprobación) y que es el sujete de este tema.
   Se calcula utilizando los siete primeros dígitos: No es desconocido y hay un solo resultado posible, solo tenemos que aplicar la formula para calcularlo. Respecto a nuestro brute force significa que en lugar de tener dos secuencias de brute forces sobre 4 números (10000 + 10000 = 20000) tenemos una fase de brute force sobre 4 números (10 000) y otra sobre tres (1000). Mos hace un máximo de 11000 PIN por probar

Calcular el Checksum WPS paso a paso

  EL primer PIN que proba reaver es 12345670.
Esto se debe a que es el PIN que atribuye por defecto el propio WPS en caso de una configuración no completa del PIN en el firmware.
Vamos a ver como se hace para deducir que 0 es el ultimo dígito tomando 1234567 como siete primeras cifrás de un PIN WPS.
Así es fácil ya que el valor de cada dígito corresponde a su posicionamiento en el PIN.

Primer paso :
  Tenemos que multiplicar cada cifra sucesivamente por 3 o 1.
El primer dígito se multiplica por 3, el segundo por uno, el tercero por tres, el cuarto por uno etc...

        digito       operación     resultado

     --------------------------------------

       1            1   x   3   =     3

       2            2   x   1   =     2

       3            3   x   3   =     9

       4            4   x   1   =     4

       5            5   x   3   =    15

       6            6   x   1   =     6

       7            7   x   3   =    21

Segundo Paso  :

Sumamos los resultados obtenidos tràs multiplicar los digtós

3   +   2   +   9   +   4   +   15   +   6   +   21   =   60

Tercer paso   :

Guardamos las unidades de la suma calculada para obtener el dígito de control y en este caso es cero (60)

Cuarto paso  :

Restamos el dígito de control a 10 guardando solo la unidad del resultado (se usa una resta con reducción por modulo 10) 10 - 0 = 10

Hemos caluclado nuestro checksum WPS y es 0

Hagamos otro.... por ejemplo calculamos el checksum del PIN 9999999

primer paso: la multiplicación
(9x3)  +  (9x1)  +   (9x3)   +   (9x1)   +   (9x3)   +   (9x1)   +   (9x3)

segundo paso: la suma
27   +   9   +   27   +   9   +   27   +   9   +   27   =   135

tercer paso: dígito de control
guardamos la unidad de nuestra suma :  135

Cuarto paso : Checksum restando el dígito de control a diez
10 - 5 = 5

El PIN WPS valido es 99999995

Fácil ¿No?
Podemos comprobar si un PIN es valido en linea de comando con wpa_cli :   

 wps_check_pin <PIN> = verify PIN checksum

algoritmo; ejemplos de código

Vamos a mirar la función en bash que redactó para WPSPIN antares_145 que es el algoritmo del cheksum WPS  "paso a paso" de forma pedagogica, para dummies.

CHECKSUM(){                                                               # función de antares_145 de crack-wifi.com
PIN=`expr 10 '*' $STRING`                                                    # $STRING corresponde a los 7 primeros dígitos del PIN
ACCUM=0                                                                             #  $ACCUM corresponde a la suma de las multiplicaciones de cada digito 
                                                             
ACCUM=`expr $ACCUM '+' 3 '*' '(' '(' $PIN '/' 10000000 ')' '%' 10 ')'`       # usamos la reducción por modulo diez para isolar cada digto
ACCUM=`expr $ACCUM '+' 1 '*' '(' '(' $PIN '/' 1000000 ')' '%' 10 ')'`         # el dígito uno por tres, el dígito 2 por 1 etc...
ACCUM=`expr $ACCUM '+' 3 '*' '(' '(' $PIN '/' 100000 ')' '%' 10 ')'`
ACCUM=`expr $ACCUM '+' 1 '*' '(' '(' $PIN '/' 10000 ')' '%' 10 ')'`
ACCUM=`expr $ACCUM '+' 3 '*' '(' '(' $PIN '/' 1000 ')' '%' 10 ')'`
ACCUM=`expr $ACCUM '+' 1 '*' '(' '(' $PIN '/' 100 ')' '%' 10 ')'`
ACCUM=`expr $ACCUM '+' 3 '*' '(' '(' $PIN '/' 10 ')' '%' 10 ')'`             

DIGIT=`expr $ACCUM '%' 10`                                                   # calculamos el dígito de control (unidad de la suma obtenida anteriormente) 
CHECKSUM=`expr '(' 10 '-' $DIGIT ')' '%' 10`                             # calculamos el checksum ( 10 - digitode control ) 
}                                                                                             

Ahora en versión mas "elegante" en un búcle while de r00tnuLL

# Función que genera el checksum. Algoritmo de ZaoChunsheng.
FUNC_CHECKSUM(){
    ACCUM=0
    while [ $PIN -ne 0 ]; do
      ACCUM=$((ACCUM += 3 * (PIN % 10)))
      PIN=$((PIN /= 10))
      ACCUM=$((ACCUM += PIN % 10))
      PIN=$((PIN /= 10))
    done
    CHECKSUM=$(((10 - ACCUM % 10) % 10))     # Por último se halla el valor para añadirlo al pin.
}

Para concluir la classe de spawn en python

#!/usr/bin/python2.7
# -*- coding: utf-8 -*-

import sys

class WPS_PIN():
    def __init__(self,pin):
        self.pin = pin # string
        self.npin = [int(i) for i in self.pin] # lista de enteros

    def is_valid(self):
        tmp = (sum([ 3 * i for i in self.npin if (i % 2 == 0 )]) + sum([ i for i in self.npin if (i % 2 == 1 )])) % 10 # checksum
        
        return 0 == tmp

    def find_valid(self):
        for i in xrange(10):
            tmp = WPS_PIN(self.pin[:-1]+str(i))
            if tmp.is_valid():
                return i

    def check(self):
        if self.is_valid():
            print "Pin",self.pin,"valido (:"
        else:
            print "Pin",self.pin,"invalido, el checksum debría ser",self.find_valid()

if __name__ == "__main__":
    wp = WPS_PIN(sys.argv[1])
    print "Pin : ",wp.pin
    wp.check()

Guardamos el código en un fichero que llamamos  wpsum.py y le otorgamos derechos de ejecución con

chmod +x wpsum.py

Para ejecutar el scrpt hacemos (una vez situados en el directorio dónde el script esta guardado)

./wpsum.py <7_primeros_dígitos_del_PIN>

  Fin de la transmisión, nos vemos en otro tema.