bloque iii

CURSO DE PROGRAMACIÓN PARALELA EN PROCESADORES GRÁFICOS


Bloque III

Estado del proyectoDavid Miraut

Marcos GarcíaRicardo Suárez


Índice

• Personal URJC

• Estado del proyecto– Visión global– Algoritmos implementados

• Extended MD5• UNRAR Attack• Office Attack• PDF Attack

– Estructura de la librería general

• Trabajo futuro

• Recursos utilizados


Personal URJC

• Director del proyecto:– Marcos García Lorenzo

• Profesor Titular Universitario (Director del Máster IGJRV)• Titulación:

– Doctor e Ingeniero en Informática por la UPM

• Trabajos anteriores:– PDI en la URJC (Coordinador de Área)– Research Fellow en TCD– Investigador de la UPM– Área de Informática en EADS (División espacio)


Personal URJC

• Equipo desarrollo:– Ricardo Suarez Mesa

• Becario de Investigación• Titulación:

– Ingeniero Informático por la ULPGC– Máster en la URJC

• Trabajos anteriores: – Becario de investigación en la URJC (Área de arquitectura)– Becario de investigación en el CSIC (Instituto de óptica)


Personal URJC (Nuevas Incorporaciones)

• Consultor Experto:– David Miraut

• Profesor en la URJC• Titulación:

– Ingeniero en Telecomunicaciones por la UPM– Estudiante de Doctorado en la URJC

• Trabajos previos:– Investigador del ESRF– Investigador de la ESA (CNES)– Investigador de la UPM (Telecomunicaciones)


Personal URJC (Nuevas Incorporaciones)

• Equipo desarrollo:– Elías Grande

• Becario de Investigación a tiempo parcial• Titulación:

– Ingeniero Técnico de Sistemas– En 5º de Ingeniería Superior en Informática


Índice

• Personal URJC




• Trabajo futuro



Visión global

• Algoritmos implementados– Algoritmos generales

• Tipos:– Algoritmos de Hashing– Algoritmos de encriptado

• Sencillos, estándares y generales• Optimizados de forma general• Estructurados en forma de librería

– Implementación de algoritmos de desencriptación específicos• Problemas específicos• Optimizados de forma específica• NO utilizan los algoritmos generales, sino adaptaciones

de los mismos


Visión global

• Algoritmos implementados– Algoritmos generales

• Algoritmos de hashing– MD5– SHA1

• Algoritmos de encriptación– AES– RC4

– Implementación de algoritmos de desencriptación específicos• Extended MD5• Office Attack• PDF Attack• UNRAR Attack


Visión global

• Objetivos y requisitos:– Implementación eficiente en arquitecturas gráficas de versiones estándar

de los algoritmos antes mencionados• Los algoritmos no se modifican en su esencia en la adaptación

– Desarrollado para Fermi

– Implementación en C estándar

• Paralelismo– Nivel de algoritmo– A nivel de datos– Proceso


Índice

• Personal URJC




• Trabajo futuro



MD5 específico

• Descripción general: MD5 ofuscado con “salt” y 1000 iteraciones

• Entrada:– Conjunto de claves que se desean probar– Salt (contenido en el fichero Shadow)

• Precondición:– Las claves se agrupan en conjuntos de claves con la misma longitud– Longitudes admitidas:

• [1..16]

• Salida:– Confirmación de que se ha obtenido la clave buscada


MD5 específico

#include <alg1_one_simulation.h>…

int nDevices = initCuda();if (nDevices == -1) return -1;…int error = MD5_cuda (entrada, nPwd, lPwd, digest, salt, pos, selectDevice, device);…freeCudaCtx();


MD5 específico

• Parámetros:– entrada: passwords concatenados– nPwd: número de passwords– lPwd: longitud de la password– digest: digest con el que comparar– salt: salt ;-)– pos: devuelve la posición en la que haya sido encontrada una coincidencia, -1 si no– selectDevice: tarjeta gráfica– device: dispositivo a usar si parámetro anterior es true

• Retorno: – 0: correcto– -1: no hay dispositivo CUDA compatible– -2: el password es menor que 1– -3: la longitud del password es mayor que 16


MD5 específico//Creación de la cadena inicial cadena = concatenar(password, salt, password) hash = MD5(cadena) cadena = concatenar(password, salt, "$1$", salt, hash, [0 ó password[0]]) hash = MD5(cadena)

for (int i=0;i<1000;i++) {

//La creación de la cadena depende de la iteración Si i es múltiplo de 2 => cadena = hash e.o.c => cadena = password

Si i es múltiplo de 3 => cadena = concatenar(cadena, salt) Si i es múltiplo de 7 => cadena = concatenar(cadena, password)

Si i es múltiplo de 2 => cadena = concatenar(cadena, password) e.o.c => cadena = concatenar(cadena, hash)

hash = md5(cadena) }

comparar(hash, entrada)


MD5 específico

• Optimizaciones finales– 1 único kernel

• Es peor el muro de memoria que la baja tasa de ocupación• El set-up pesa con 1000 iteraciones• La comparación en el mismo kernel

– Uso de memoria compartida para:• Hash, password, temporales

– Memoria de constantes (todos los hilos acceden a la vez – en caché)• Salt, hash de entrada

– Accesos no bloqueantes a memoria compartida– Agrupación en palabras del mismo tamaño

• Distinta configuración de bloques e hilos


MD5 específico

• Optimizaciones finales– Caché de nivel 1 a 16K

• La opción por defecto fue la óptima, sino no caben en memoria compartida todos los datos

• No se usó la memoria de texturas porque en Fermi la L1 lo hace poco necesario

– Desenrollado del bucle principal• Eliminar las condiciones if. 2 * 3 = 6 etapas -> 4 posibilidades (2^2)• Impacto mínimo, no se siguió desenrollando

– Desenrollados implícitos y explícitos de bucles de pequeñas dimensiones

• Resultado con claves de 8 bits– 830.000 claves/segundo


MD5 específico

• Planificación– Multikernel

• Baja sobrecarga en Fermi• Maximizar la ocupación

– Limitar el número de registros– Optimizar el uso de la memoria compartida

• Optimizaciones– Desenrollado– SM– Coalescencia– Caché– Texturas– Constantes

– Único kernel• Demostró ser la mejor opción

– Es peor el muro de memoria que la baja tasa de ocupación– El set-up pesa con 1000 iteraciones


MD5 específico

• Resultados multikernel– 128 Hilos

• MD5Todas_kernel → Occupancy = 0.5 ( 24 / 48 )• MD5Ofusc1_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5Ofusc2_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5Ofusck1_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5Ofusck2k3_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5Ofusck4_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5Ofusck5k6_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5Complete11_kernel → Occupancy = 0.666667 ( 32 / 48 )• MD5_Complete8_kernel → Occupancy = 0.666667 ( 32 / 48 )

• Si se aumenta el tamaño de bloque hasta los 256 hilos, en los kernels que no usan memoria compartida


MD5 específico

• Resultados multikernel (bucle principal desenrollado):– Config 1 → Shared Memory, 128– Config 2 → Shared Memory, 128, TEXTURES– Config 3 → Shared Memory, 128, L1 (16K)– Config 4 → Shared Memory, 128, TEXTURES, L1 (16K)– Config 5 → 128, TEXTURES– Config 6 → Shared Memory (128 hilos), 256, TEXTURES

Tamaño Config 1 Config 2 Config 3 Config 4 Config 5 Config 6

5000 0,094 0,084 0,099 0,099 0,290 0,101

50000 0,740 0,730 0,760 0,760 2,820 0,820

500000 6,550 6,310 7,230 7,290 27,450 7,420

5000000 61,310 40,410 70,320 40,410 -- 48,420


Índice

• Personal URJC




• Trabajo futuro



UNRAR Attack

• Descripción general– Desencripta ficheros RAR – Basado en la codificación por bloques (EBC) de AES– Utiliza el mismo SALT en todos los bloques– Comprueba la cadena final (c4 3d 7b 00 40 07 00)

• Precondición– Funciona con la 3.x encriptados con la opción “-hp” (datos y metadatos) – Todas las claves deberán tener el mismo tamaño

• Entrada– Fichero RAR– Patrón de las claves– Conjunto de caracteres a probar

• Salida– Imprime la clave encontrada por pantalla.


UNRAR Attack

• Uso– Aún no está estructurado como una librería

– Opción 1• Ejecutable que recibe los tres parámetros por la entrada

– Juegos de caracteres: » [all; lower; upper; uppLow; numbers; numLow; numUpp; numLowUpp]

– ./unrarhp encrypted_archive.rar 'foo???‘ all

– Opción 2:• Función • void do_file(const char *file, const char *pattern, const char *charset)


UNRAR Attack

• Algoritmo

Salt = ExtraerSalt(Fichero)Cadena = ExtraerCadena(Fichero)

RecursosCPU = 0.75 * CalcularRecursosCPU()RecursosGPU = 0.98 * CalcularResoruceGPU()Recursos = min(RecursosCPU, RecursosGPU)

For (i = 0; i < numClaves(); i += Recursos){

claves = ExpandirClaves(Patron, i, i + Recursos)hashes = SHA1(Salt, Claves)TestPassword(Cadana, hashes)

}


UNRAR Attack

• Características:– Utiliza el SHA1 y el AES estándar

• El AES es el cuello de botella

– Cuando se usa 1 única GPU, no hace falta traerse los datos de memoria

– Se implementó una versión multiGPU• Requiere cambiar el contexto

– Requiere passwords de la misma longitud– Se mejoró la funcionalidad de la expansión de claves

• Resultados: – Los mismos que los obtenidos con el SHA1 y el AES estándar


Índice

• Personal URJC




• Trabajo futuro



Office Attack

• Descripción general:– Desencriptado de fichero Microsoft Office– 4 versiones de encriptación (convención nombres CNI)

• 97 (40bits)• 2003 (RC4)• 2007 (Estándar) • 2010 (Agile)

– Versión CPU adaptada para trabajar con múltiples passwords


Office Attack

• Precondición• Todos los passwords deben tener el mismo tamaño

• Entrada– Salt (hard-coded)– Cadena de comparación (hard-coded)

• Salida– Clave encontrada por pantalla


Office Attack

• Uso– Programa en el que se incluyen como variables hard-

coded el salt y la cadena de comparación de:• Un fichero de la versión del 97• Un fichero de la versión del 2003• Un fichero de la versión del 2007• Un fichero de la versión del 2010

– No tiene estructura de librería


Office Attack

• Características– Cada algoritmo define un algoritmo de hash y uno de

encriptación• V97

– RC4 y MD5

• V2003– RC4 y SHA1

• V2007– AES (ECB) y SHA1 (50.000 iteraciones)

• V2010– AES (CBC) y SHA1 (50.000 iteraciones)

– Es posible volver a la versión en CPU descimentando el código oportuno


Office Attack

• Descripción de las funciones utilizadas• V97

– Algoritmo: test_office_40bits (attack_office.c)– Hash: H_MD5 (funciones_cripto.h)– Encriptación: RC4_k_de (funciones_cripto.h)

• V2003– Algoritmo: test_office_rc4 (attack_office.c)– Hash: H_SHA1 (funciones_cripto.h)– Encriptación: RC4_k_de (funciones_cripto.h)


Office Attack

• Descripción de las funciones utilizadas• V2007

– Algoritmo: test_office_standard (attack_office.c)– Hash: H_SHA1_LOOP y H_SHA1(funciones_cripto.h)– Encriptación: AES_ECB_k_de (funciones_cripto.h)

• V2010– Algoritmo: test_office_agile (attack_office.c)– Hash: H_SHA1_LOOP y H_SHA1(funciones_cripto.h)– Encriptación: AES_CBC_k_de (funciones_cripto.h)


Office Attack

• Optimizaciones – RC4:

• Puesto que la entrada es fija se elimina el operador módulo

– MD5:• Se elimina el bucle que prepara los datos si la entrada tiene una longitud menor que 16 (la

mayoría de los casos)

– SHA1: • Como se conoce el tamaño de la entrada y es múltiplo de 4 en lugar de leer char, se leen

enteros (x4) • Si la entrada es de 16 bits se elimina un bucle (la mayoría de los casos)• Como el valor de las posiciones de memoria compartida son conocidas en la etapa de

transformaciones, se omiten las primeras 20 operaciones de las 80• En la versión estándar y en la agile, el bucle del SHA1 se fusiona en un único kernel

– Implementada en multikernel

– AES• Se utiliza el estándar multitarjeta


Office Attack

• Optimizaciones – Comparación de la clave fuera de la GPU

• No es demasiada sobrecarga puesto que el resto de etapas son mucho más complejas• Podría funcionar en las versiones del 97 y del 2000

– Las partes que se ejecutan en la CPU están paralelizadas con OpenMP– El tamaño de los bloques se determinó experimentalmente

– Desenrollado de bucles no mejoraba la implementación


Office Attack

• Resultados (tamaño de clave 8bytes – poco relevante)– 40 bits: 2,5M p/s– RC4: 7,9M p/s– Estándar: 10,9m p/s – 21,1m p/s (1 tarjeta - 2

tarjetas)– Agile: 5,4m p/s – 10,7m p/s (1 tarjeta – 2 tarjetas)


Índice

• Personal URJC




• Trabajo futuro



PDF Attack

• Descripción general– Desencriptado de ficheros PDF– Dos versiones:

• R2• R34


PDF Attack

• Precondición– Todos los passwords deben tener el mismo tamaño

• Entrada– Datos de verificación

• Metadatos (forma la clave del RC4 con el password –R34)• Texto plano (sólo se usa en R34, en R2 se usa una cadena

estándar)• Cadena de comparación

• Salida– Se indica por pantalla la clave encontrada


PDF Attack

• Uso– Programa en el que se incluyen como variables hard-coded los

metadatos, el texto plano y la cadena de comparación de un fichero:• PDF R2• PDF R34

– No tiene estructura de librería

• Características– Los dos algoritmos utilizan un algoritmo de hashing (MD5) y

otro de encriptación (RC4)


PDF Attack

• Descripción de las funciones utilizadas• R2

– Algoritmo: test_pdf_r2 (attack_pdf.c): » Parámetros de entrada

• Estructura • Lista de passwords

– Hash: H_MD5 (funciones_cripto.h)– Encriptación: RC4_deCmp (funciones_cripto.h)


PDF Attack

• Descripción de las funciones utilizadas• R34

– Algoritmo: test_pdf_r34 (attack_pdf.c)» Parámetros de entrada

• Estructura • Lista de passwords

– Hash: H_MD5 (funciones_cripto.h)» Versión normal y de 50 iteraciones (con entradas del mismo

tamaño)– Encriptación: RC4_k_de y RC4_deCmp (funciones_cripto.h)


PDF Attack

• Optimizaciones – RC4:

• Comparación de claves en GPU para el último RC4• En el PDF V34:

– Tamaño de entrada fijo. No es necesaria una operación módulo– RC4 normal– Fusión de RC4 encadenados


PDF Attack

• Optimizaciones – MD5:

• Tamaño de entrada fijo. Se leen enteros en lugar de char• En el PDF V34:

– El bucle de MD5 encadenados se fusiona en un kernel

– Las partes que se ejecutan en la CPU están paralelizadas con OpenMP

– El tamaño de los bloques se determinó experimentalmente

• Resultados (tamaño de clave 8 bytes – poco relevante)– R2: 10,7M p/s– R34: 1,7M p/s


Índice

• Personal URJC




• Trabajo futuro



Estructura de la librería general

• Descripción– Implementa de forma general los siguientes

algoritmos• Hashing:

– MD5– SHA1

• Decodificación:– AES– RC5



• MD5– Precondición

• Todas las claves deben de tener la misma longitud

– Entrada• Lista de claves, salt, hash con el que comparar el resultado• Dispositivo en el que se ejecuta el kernel

– Salida• Posición de la clave correcta• -1 si dicha clave no se encuentra



• SHA1– Precondición

• Todas las claves deben de tener la misma longitud• No se puede dejar la salida en la memoria de la tarjeta gráfica si se usa

multiGPU

– Entrada• Lista de claves• Dispositivo en el que se ejecuta el kernel o multiGPU• Posibilidad de dejar el resultado en la memoria de la tarjeta gráfica• Iteraciones

– Salida• Puntero con el HASH de la entrada

– Puntero a MP o a la memoria de la GPU



• AES– Precondición

• Todas las claves deben tener la misma longitud• El bloque a desencriptar tiene un tamaño de 16 bits

– Entrada• Lista de claves, vectores de inicialización, bloque a desencriptar• Dispositivo en el que se ejecuta el kernel o multiGPU• Posibilidad de dejar el resultado en la memoria de la tarjeta

gráfica• Los datos de entrada pueden cogerse de la GPU o de MP

– Salida• Bloque desencriptado



• RC4– Precondición

• Todas las claves deben tener la misma longitud

– Entrada• Texto a descifrar, claves

– Salida• Texto cifrado



• MD5#include <MD5_1-8.h>…

int nDevices = initCuda1_8();if (nDevices == -1) return -1;…int error = MD5_cuda(entrada, nPwd, lPwd, digest, offset, pos, selectDevice, device);…freeCudaCtx1_8();



• Parámetros:– Pwd: passwords vectorizados– nPwd: número de passwords– pwdL: longitud de los passwords– offset: espacio sin usar en la lista de passwords– pos: posición donde se ha encontrado un digest coincidente, -1 si no se

encuentra– selectDevice: se fija si se pasa el dispositivo a usar en el siguiente parámetro

• Retorno:– 0: correcto– -1: no hay dispositivo CUDA compatible– -2: el password es menor que 1– -3: la longitud del password es mayor que 16



• SHA1#include <SHA1.h>…int nDevices = initCuda ();if (nDevices == -1) return -1;…int mem = avaMemCuda(device);…int error = SHA1_call_kernel(digest, entrada, lEnt, nPsswd, offset, iteration, mulGPU, setDevice,

deviceSelect, copyToCPU, d_digest); …freeCudaSHA1(d_digest);…freeCudaCtx();



• Parámetros entrada:– entrada: cadenas de entrada– lEnta: longitud cadenas de entrada– nPsswd: número de cadenas– offset: espacio sin usar en las cadenas de entrada– mulGPU: utilizar multiGPU– setDevice: en el caso de singleGPU se puede fijar que

tarjeta usar con el siguiente parámetro– deviceSelect: se selecciona que tarjeta usar– copyToCPU: se copian los datos obtenidos de

CPU a GPU



• Parámetros salida:– digest: vector de resultados en CPU– d_digest: vector resultado en GPU

• Retorno: – 0: correcto– -1: no hay dispositivo CUDA compatible



• AES#include <rijndae.ch>…int error = initRijndael(key, lKey, nKey, initVector, lIv, mulGPU, enGPU, dAesKey, dAesIv,

selectDevice, device);if (error == -1) return -1;…int error = blockDecryptRijndael(input, lInput, d_salida);…//Libera los recursos tanto en la CPU como la GPUdestroyRijndael(); …



• Parámetros de inicialización:– key: vector claves– lKey: longitud claves– nKey: número de claves– initVector: vectores de inicialización– lIv: longitud vector inicialización– mulGPU: ejecución en múltiples GPUs– enGpu: los datos se encuentran en la GPU– dAesKey: puntero a las claves en la GPU– dAesIv: puntero a los vectores de inicialización en GPU– selectDevice: indica si se va a seleccionar algún dispositivo en concreto– device: dispositivo a usar



• Parámetros de ejecución– input: bloque a desencriptar– lInput: tamaño del bloque– salida: bloque desencriptado




• RC4#include <rc4.h>…

int nDevices = initCuda();if (nDevices == -1) return -1;…int error = rc4_call_kernel(key, lKey, text, lText, nKey, cypherT, selectDevice, device);…freeCudaCtx();



• Parámetros de inicialización:– key: vector claves– lKey: longitud claves– nKey: número de claves– text: texto a descifrar– lText: longitud de la cadena a descifrar– selectDevice: indica si se va a seleccionar algún dispositivo en concreto– device: dispositivo a usar




• Optimizaciones – En todas las implementaciones se ha cuidado que no existan bloqueos

en memoria compartida– Se ha intentado maximizar el uso memoria compartida– Se ha intentado maximizar la tasa de ocupación– Desenrollado de bucles automático y manual (ya está implementado)– Caché L1 automática

– AES: • Sólo se almacenan 4 de las 8 tablas en MC. El resto se calculan dinámicamente• Se ha metido en memoria de constantes 1 tabla para la expansión de claves

(RCOM) y el vector de inicialización• Se intentó, sin éxito, evitar la expansión de clave completa


Índice

• Personal URJC




• Trabajo futuro



Líneas de trabajo futuro

• Generador de claves coalescente – Trabajar de forma coalescente desde el principio– Problema: desperdicio de espacio por alineamientos de 32 bits

• Tratar de evitar los writebacks de memoria gráfica a memoria principal (en Office y Pdf Attack principalmente)

• Fusión de Kernels (en Office y Pdf Attack principalmente)– Fusionar operaciones de distinto tipo– Pensar el uso de la memoria compartida

• Mejorar la estructura de la librería

• AMD

• Nuevos algoritmos


Índice

• Personal URJC




• Trabajo futuro



Recursos utilizados

• Librerías– OpenSSL (http://www.openssl.org/)– Cuda Multiforcer (http://www.cryptohaze.com/multiforcer.php)– Unrarhp (http://blog.zorinaq.com/?e=15)

• Libros– CUDA

• CUDA by Example: An Introduction to General-Purpose GPU Programming. Jason Sanders, Edward Kandrot

• Programming Massively Parallel Processors: A Hands-on Approach (Applications of GPU Computing Series). David B. Kirk, Wen-mei W. Hwu

– Criptografía:• The Design of Rijndael: AES - The Advanced Encryption Standard (Information Security and

Cryptography). Joan Daemen, Vincent Rijmen

• Handbook of Applied Cryptography (Discrete Mathematics and Its Applications) . Alfred Menezes, Paul van Oorschot , Scott Vanstone

http://www.openssl.org/

http://www.cryptohaze.com/multiforcer.php

http://blog.zorinaq.com/?e=15


Recursos utilizados

• Páginas Web– The MD5 Message-Digest Algorithm (http://www.ietf.org/rfc/rfc1321.txt)– Secure Hash Standard (http://www.itl.nist.gov/fipspubs/fip180-1.htm)– The AES encryption algorithm (http://www.samiam.org/rijndael.html)– Hashkill (http://hashkill.sourceforge.net/)– John Savard's Home Page (http://www.quadibloc.com/crypto/co040401.htmUS)– Secure Hash Algorithm 1 (SHA1) RFC 3174 (http://rsync.tools.ietf.org/html/rfc3174)– Jeff Moser, Moserware (

http://www.moserware.com/2009/09/stick-figure-guide-to-advanced.html)– OpenSSl project (http://www.openssl.org/Wikipedia)– Wikipedia

• Block cipher (http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation)• Padding (http://en.wikipedia.org/wiki/Padding_%28cryptography%29)• Initialization vector (http://en.wikipedia.org/wiki/Initialization_vector)• Criptografía simétrica (http://es.wikipedia.org/wiki/Criptograf%C3%ADa_sim%C3%A9trica) • Criptografía asimétrica (http://es.wikipedia.org/wiki/Criptograf%C3%ADa_asim%C3%A9trica)

http://www.ietf.org/rfc/rfc1321.txt

http://www.itl.nist.gov/fipspubs/fip180-1.htm

http://www.samiam.org/rijndael.html

http://hashkill.sourceforge.net/

http://www.quadibloc.com/crypto/co040401.htmUS

http://rsync.tools.ietf.org/html/rfc3174

http://www.moserware.com/2009/09/stick-figure-guide-to-advanced.html

http://www.openssl.org/Wikipedia

http://en.wikipedia.org/wiki/Block_cipher_modes_of_operation

http://en.wikipedia.org/wiki/Padding_(cryptography)

http://en.wikipedia.org/wiki/Initialization_vector

http://es.wikipedia.org/wiki/Criptograf%C3%ADa_sim%C3%A9trica

http://es.wikipedia.org/wiki/Criptograf%C3%ADa_asim%C3%A9trica

bloque iii

Documents