anÁlisis y mejora del rendimiento del...
TRANSCRIPT
INSTITUTO POLITÉCNICO NACIONAL
UNIDAD PROFESIONAL INTERDISCIPLINARIA DE INGENIERIA Y CIENCIAS
SOCIALES Y ADMINISTRATIVAS
SECCIÓN DE ESTUDIOS DE POSGRADO E INVESTIGACIÓN
ANÁLISIS Y MEJORA DEL RENDIMIENTO DEL
ALGORITMO AES PARA SU UTILIZACIÓN EN
TELÉFONOS MÓVILES
TESIS QUE PARA OBTENER EL GRADO DE
MAESTRA EN CIENCIAS EN INFORMÁTICA
PRESENTA L.C.I NANCY PAOLA GALVEZ MEZA
DIRECTOR DE LA TESIS:
DR. ERIC MANUEL ROSALES PEÑA ALFARO.
MÉXICO D.F. 2014
2 | P á g i n a
3 | P á g i n a
CARTA CESIÓN DE DERECHOS
En la Ciudad de México, D.F. el día 10 del mes de marzo del año 2014, el (la) que suscribe
Nancy Paola Galvez Meza alumna del Programa de Maestría en informática, con número
de registro B102323 , adscrita a la sección de estudios de posgrado e investigación de la
Unidad profesional interdisciplinaria de ingeniería y ciencias sociales y administrativas,
manifiesta que es la autora intelectual del presente trabajo de Tesis bajo la dirección del
Dr. Eric Manuel Rosales Peña Alfaro y cede los derechos del trabajo titulado “Análisis y
mejora del rendimiento del algoritmo AES para su utilización en teléfonos móviles” al
Instituto Politécnico Nacional para su difusión, con fines académicos y de investigación.
Los usuarios de la información no deben reproducir el contenido textual, gráficas o datos
del trabajo sin el permiso expreso del (de la) autor(a) y/o director(es) del trabajo. Este
puede ser obtenido escribiendo a las siguientes direcciones [email protected]
y/o [email protected]. Si el permiso se otorga, el usuario deberá dar el
agradecimiento correspondiente y citar la fuente del mismo.
Galvez Meza Nancy Paola
Nombre y firma del alumno(a)
INSTITUTO POLITÉCNICO NACIONAL
SECRETARÍA DE INVESTIGACIÓN Y POSGRADO
4 | P á g i n a
Contenido General
Agradecimientos .............................................................................................................................................. 12
Resumen .......................................................................................................................................................... 13
Abstract ........................................................................................................................................................... 14
Introducción .................................................................................................................................................... 15
Objetivos.......................................................................................................................................................... 17
CAPITULO I Fundamentos y Preliminares ........................................................................................................ 19
1.1 Introducción Histórica .................................................................................................................... 19
1.2 Conceptos Básicos .......................................................................................................................... 28
1.2.1 Seguridad de la información .......................................................................................................... 28
1.2.2 Criptografía .................................................................................................................................... 29
1.2.3 Criptosistemas ............................................................................................................................... 31
1.2.4 Criptoanálisis.................................................................................................................................. 33
1.3 Criptografía de clave secreta .......................................................................................................... 34
1.3.1 Cifrado de bloques ......................................................................................................................... 37
1.3.2 Cifrado de Flujo .............................................................................................................................. 37
1.4 Criptografía de clave pública..................................................................................................................... 38
1.5 Algoritmos HASH o de resumen ..................................................................................................... 39
1.6 Comparativa entre algoritmos Simétricos y asimétricos ................................................................ 41
CAPITULO II Criptografía en arquitecturas móviles y su programación .......................................................... 44
2.1 Seguridad en Telefonía Móvil ......................................................................................................... 44
2.1.1 El móvil como un mini PC .............................................................................................................. 44
2.1.2 La importancia de la seguridad ...................................................................................................... 46
5 | P á g i n a
2.2 Incidentes de seguridad ................................................................................................................. 46
2.2.1 Tipos de Malware en los Smartphones ......................................................................................... 48
2.2.2 Malware en Sistemas Operativos Android ..................................................................................... 49
2.3 Medidas de seguridad y prevención de riesgos ............................................................................. 50
2.4 Telefonía móvil y su criptografía .................................................................................................... 51
2.5 Debilidades en la Seguridad ........................................................................................................... 52
CAPITULO III Criterios y elección de un algoritmo criptográfico para dispositivos móviles ........................... 57
3.1 Retos a superar con la elección ...................................................................................................... 57
3.1.1 Creciente capacidad de cómputo de los computadores modernos. .............................................. 57
3.1.2 Recursos Computacionales. ........................................................................................................... 58
3.1.3 Incremento de dispositivos móviles............................................................................................... 58
3.1.4 Velocidad en el proceso de encriptación y desencriptación. ........................................................ 58
3.1.5 Comparativa energética entre los dispositivos móviles con mayor cuota del mercado. ............... 59
3.2 Fundamentación de la elección ..................................................................................................... 63
3.2.1 Criterios de elección del algoritmo base AES ................................................................................. 63
3.2.2 Algoritmo simétrico ....................................................................................................................... 63
3.2.3 Análisis y comparativa de algoritmos simétricos .......................................................................... 64
3.2.4 Algoritmo elegido AES: Conceptos básicos ................................................................................... 72
3.2.5 Desarrollo ....................................................................................................................................... 74
3.2.6 Seguridad de AES .......................................................................................................................... 74
3.2.7 Funcionamiento básico del algoritmo elegido: AES ....................................................................... 76
CAPITULO IV Propuesta de mejoras al algoritmo ............................................................................................ 81
4.1 Entorno de trabajo ......................................................................................................................... 82
4.1.1 Microprocesador para móviles ..................................................................................................... 82
6 | P á g i n a
4.1.2 Kit de desarrollador ARM- Keil uVision4 ....................................................................................... 82
4.1.3 Lenguaje de programación C ......................................................................................................... 83
4.1.4 Rijndael Inspector 1.1 .................................................................................................................... 83
4.1.5 Battery Monitor Widget ................................................................................................................ 84
4.2 Implementación de AES ................................................................................................................. 85
4.2.1 Funcionamiento del programa ....................................................................................................... 85
4.2.2 Distribución del programa ............................................................................................................. 86
4.3 Mejoras de rendimiento ................................................................................................................ 88
4.3.1 Complejidad temporal del Algoritmo ............................................................................................ 89
4.3.2 Análisis del algoritmo AES .............................................................................................................. 89
4.3.3 Implementación de las mejoras ..................................................................................................... 92
4.3.4 Rendimiento tras la aplicación de todas las mejoras ................................................................... 106
4.3.5 Mejoras al Consumo de energía .................................................................................................. 111
4.4 Propuestas a futuro de mejoras para la seguridad....................................................................... 112
4.4.1 Obtención de números aleatorios ............................................................................................... 113
4.4.2 Uso de máscaras aleatorias .......................................................................................................... 114
Conclusiones .................................................................................................................................................. 116
Glosario ......................................................................................................................................................... 120
Bibliografía ..................................................................................................................................................... 123
Anexos ........................................................................................................................................................... 133
Anexos ........................................................................................................................................................... 133
Resultados de las rondas del algoritmo AES al funcionar con una matriz de ejemplo ............................. 133
Modificaciones .............................................................................................................................................. 134
Modificaciones: Archivo main.h ................................................................................................................ 134
7 | P á g i n a
Modificaciones: aes.h ................................................................................................................................ 134
Modificaciones: main.c ............................................................................................................................. 135
Modificaciones: aes.c ................................................................................................................................ 141
Tablas S-Box ............................................................................................................................................... 150
Código fuente de la implementación del algoritmo Aes. .......................................................................... 151
Main.c ................................................................................................................................................... 151
Aes.c ...................................................................................................................................................... 157
Main.h ................................................................................................................................................... 172
Aes.h ..................................................................................................................................................... 172
8 | P á g i n a
Índice de figuras
Figura 1-1 Escítala espartana ........................................................................................................................... 20
Figura 1-2 Disco de Alberti .............................................................................................................................. 22
Figura 1-3 Cuadro de Vigenère ........................................................................................................................ 23
Figura 1-4 Máquina Enigma ............................................................................................................................ 24
Figura 1-5 Bombe de Turing ............................................................................................................................ 25
Figura 1-6 Colossus .......................................................................................................................................... 25
Figura 1-7 Eniac ............................................................................................................................................... 26
Figura 1-8 Criptografía ..................................................................................................................................... 31
Figura 1-9 Esquema de los algoritmos de clave secreta .................................................................................. 35
Figura 1-10 Esquema de algoritmos de clave pública ..................................................................................... 38
Figura 2-1 Criptografía en redes GSM ............................................................................................................. 51
Figura 3-1: Promedio en Mbits/s para distintas computadoras con true crypt ............................................... 66
Figura 3-2 Tiempo de ejecución en cada prueba por algoritmo en la herramienta CyaSSL .......................... 67
Figura 3-3 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta Cryptool ...... 68
Figura 3-4 Comparativa en función del software (en Mbits/s) ........................................................................ 70
Figura 3-5 Rendimiento promedio en Mbits/s de todos los algoritmos analizados en los correspondientes 5
equipos ............................................................................................................................................................ 71
Figura 3-6 Proceso de encriptación del algoritmo AES .................................................................................... 72
Figura 3-7 Diagrama general del algoritmo AES y su funcionamiento ............................................................ 77
Figura 3-8 Función Addround .......................................................................................................................... 78
Figura 3-9 Función Bytesub ............................................................................................................................. 78
Figura 3-10 Función Shiftrows ......................................................................................................................... 78
Figura 3-11 Función MixColumns .................................................................................................................... 79
9 | P á g i n a
Figura 3-12 Proceso de descifrado del Algoritmo AES ................................................................................... 79
Figura 4-1 Pantalla principal del software KeilUvision .................................................................................... 82
Figura 4-2 Pantalla principal de Battery Monitor Widget................................................................................ 84
Figura 4-3 Diagrama de funcionamiento del algoritmo .................................................................................. 85
Figura 4-4 Proceso para un bloque de cifrado dependiendo del tamaño de clave ........................................ 90
Figura 4-5 Generación de claves transpuestas ............................................................................................... 95
Figura 4-6 : Tiempo total de cifrado de un bloque ........................................................................................ 107
Figura 4-7: Tiempo total de descifrado de un bloque ................................................................................... 107
Figura 4-8 Rendimiento de las mejoras en un bloque .................................................................................. 108
Figura 4-9 Rendimiento total de las mejoras con 10 bloques....................................................................... 109
Figura 4-10 eficiencia durante el proceso de descifrado .............................................................................. 110
10 | P á g i n a
Índice de Tablas
Tabla 1-1 Comparativa entre criptografía simétrica y asimétrica .................................................................... 41
Tabla 2-1 Empresas líderes en el mercado móvil ............................................................................................ 44
Tabla 2-2 Sistemas operativos lideres para mercado móvil ............................................................................ 45
Tabla 2-3 Malware principal para telefonía móvil ........................................................................................... 48
Tabla 2-4 Malware atacante en sistema operativo Android ............................................................................ 49
Tabla 2-5 Medidas de seguridad ...................................................................................................................... 50
Tabla 3-1 Velocidad de los algoritmos de Encriptación. .................................................................................. 59
Tabla 3-2 Rendimiento de batería y especificaciones de móviles con mayor afluencia en el mercado actual
(año 2012-2013) .............................................................................................................................................. 60
Tabla 3-3 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta truecrypt ........ 66
Tabla 3-4 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta CyaSSL ............ 67
Tabla 3-5 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta Cryptool ........ 67
Tabla 3-6 Resultados Finales: Uniendo las tres herramientas. Unidad/MB-S .................................................. 70
Tabla 3-7 Velocidad promedio en Mbits/s de todos los algoritmos analizados en los correspondientes 5
equipos ............................................................................................................................................................ 71
Tabla 4-1 parámetros de inicialización ............................................................................................................ 86
Tabla 4-2 resumen de funciones de la implementación del algoritmo AES ..................................................... 86
Tabla 4-3 Medición del tiempo en cada función del algoritmo AES medidos en microsegundos (µs) ............ 90
Tabla 4-4 Mejoras de rendimiento en la extracción de datos.......................................................................... 94
Tabla 4-5 Mejoras en la función keyexpansion ................................................................................................ 96
Tabla 4-6 Mejoras Addroundkey ...................................................................................................................... 97
Tabla 4-7 Mejoras subBytes(). ......................................................................................................................... 98
Tabla 4-8 Mejoras en ShiftRows ...................................................................................................................... 99
11 | P á g i n a
Tabla 4-9 Pasos de mixcolumns .................................................................................................................... 100
Tabla 4-10 Mejoras en mixcolumns ............................................................................................................... 101
Tabla 4-11 Mejoras en invshiftrows ............................................................................................................... 102
Tabla 4-12 Mejoras en inv subytes ................................................................................................................ 102
Tabla 4-13 Mejoras invMixColumns(). ........................................................................................................... 105
Tabla 4-14 Tiempo total cifrando un bloque ................................................................................................. 106
Tabla 4-15 Uso de la batería antes y después de las mejoras en miliamperios ............................................. 112
12 | P á g i n a
Agradecimientos
Al término de este trabajo que ahora presento como culminación de todo el esfuerzo, desvelos y lágrimas
que conllevó, no puedo dejar de lado a las personas que me han apoyado durante todo este proceso y que
con sus cuidados y consejos han sido participes de este logro:
A mis padres con todo mi cariño y mi amor; las personas que hicieron todo en la vida para que yo pudiera
lograr mis sueños, por motivarme y darme la mano cuando sentía que el camino se terminaba, a ustedes por
siempre mi corazón y mi agradecimiento. A mi madre la Lic. Rosa Lilia Meza Torres por ser siempre el
ejemplo, guía y ángel guardián que necesitaba en los momentos más oscuros de agonía y desesperación. A
mi padre el Lic. Javier Galvez Zarazúa por sus consejos, apoyo y enseñanzas a lo largo de mi vida; A ambos
por que fueron los primeros maestros que tuve y cada palabra y acción han sido lecciones que han forjado lo
que ahora soy.
A mis hermanas Lilia Alejandra y Leslie Jackeline, con quienes tengo un vínculo invaluable, agradeciendo su
apoyo y ayuda incondicional en los momentos en los que la incertidumbre me ganaba la partida. Por sus
sempiternas conversaciones sobre cualquier tema y su efectiva mansedumbre en mis días más hastiosos.
A mi Familia quienes siempre han pensado lo mejor de mí, creyendo en mi capacidad aun cuando yo misma
dudaba de ella.
Al Dr. Eric Manuel Rosales Peña Alfaro por sus consejos y guía en la realización de esta tesis y en mi
desarrollo académico, por ser un ejemplo de un profesional comprometido y ávido de conocimiento; un gran
modelo a seguir. Al Dr. Mauricio Procel Moreno por guiarme desde el inicio de la maestría, por su interés y
por compartir todo su conocimiento y su tiempo con mis ilimitadas dudas. A mis profesores, que en este
andar por la vida, influyeron con sus lecciones y experiencias en formarme como una persona de bien y
preparada para los retos que pone la vida.
A mis amigos que han sido protagonistas de los ratos más amenos y divertidos que guardo en mi memoria.
Finalmente, mis agradecimientos a todo el cuerpo docente y administrativo de UPIICSA del Instituto
Politécnico Nacional por su guía y conocimientos trasmitidos. Los llevare siempre como una parte de mi y
espero enorgullecer a la alma mater que me abrió sus puertas permitiéndome convertirme en una
profesional que enaltezca el nombre del IPN.
Nancy Paola Gálvez Meza
13 | P á g i n a
Resumen
La presente tesis se enmarca dentro del estudio y desarrollo de algoritmos criptográficos para dispositivos
móviles. Concretamente, se enfoco en el desarrollo de una mejora en la implementación del algoritmo AES
en un dispositivo móvil (teléfono celular) con arquitectura ARM de 32 bits. Se realizó un análisis de los
Algoritmos más utilizados con respecto a su desempeño (en tiempo y seguridad) y tras elegir el algoritmo
más idóneo (AES) se han aplicado diversas técnicas para mejorar su implementación de manera que se
ahorren al máximo los recursos limitados que un dispositivo móvil posee.
Para lograr reducir el tiempo de procesamiento se han aplicado técnicas específicas, como el Loop unrolling
y transposición de matrices, con las que se ha conseguido reducir el tiempo de procesamiento en un
aproximado de 50% en la operación de cifrado y un 80% en la operación de descifrado.
En conclusión, con estas mejoras se logra extender la vida de la batería permitiendo que el dispositivo móvil
pueda tener una mejor administración de sus recursos y al tratarse de una mejora sobre una
implementación, no se toca la estructura o seguridad del algoritmo en cuestión.
Palabras clave: Arquitectura móvil, dispositivos móviles, algoritmos criptográficos, AES, cifrado, seguridad,
eficiencia, mejora, ARM.
14 | P á g i n a
Abstract
The present thesis places inside the study and development of cryptographic algorithms for mobile devices.
Concretely, It focus in the development of an improvement in the implementation of the algorithm AES in a
mobile device (cell phone) with ARM architecture over 32 bits. There was done an analysis of the most used
Algorithms regard to the performance (in time and safety) and, after choosing the most suitable algorithm
(AES), there have applied diverse technologies in order to improve the implementation so it can save the
maximum of the limited resources that a mobile device possesses.
To manage to reduce the time of processing specific technologies have been applied, as the Loop unrolling
and transposition of matrices, it has managed to reduce the time of processing in about 50 % in the
operation of coding and 80 % in the operation of deciphered.
In conclusion, with these improvements it is achieved to extend the battery life allowing that the mobile
device could have a better administration of his resources and being itself an improvement on an
implementation there does not touch the structure or security of the algorithm in question.
Key words: Mobile Architecture, Mobile devices, Cryptographic algorithms, AES, coding, security, efficiency,
improvement, ARM.
15 | P á g i n a
Introducción
Diariamente más dispositivos móviles (como teléfonos celulares, tabletas, PDAs, tarjetas inteligentes, por
mencionar algunos) se conectan a redes inalámbricas, ya sea para realizar consultas o transacciones
comerciales. Sin embargo, los dispositivos móviles son aún más inseguros que los tradicionales teléfonos
debido a que utilizan el aire para transmitir la comunicación, por tanto cualquier persona está en posibilidad
de alterarla o robarla. Por lo anterior es necesario tener herramientas altamente confiables y eficientes que
permitan proteger los datos y así satisfacer las demandas de seguridad de los usuarios.
En los últimos años, la telefonía móvil ha redefinido la forma de comunicación entre las personas. Los
dispositivos electrónicos han evolucionado vertiginosamente en potencia, rendimiento y sobre todo en
nuevas funcionalidades.
En consecuencia, si bien las innovaciones en tecnología para dispositivos móviles vienen a simplificar
muchas tareas diarias que en otro caso requerirían de un equipo de escritorio o portátil, también quedan
expuestos a riesgos de seguridad.
Según recientes investigaciones, el 55% de los empleados almacenan archivos importantes de su trabajo,
correos electrónicos y documentos privados sin seguridad alguna. Un 40% almacenan sus archivos fuera de
la red de la empresa, un 21% en memorias USB, 14% en sus computadoras personales y un 9% en celulares y
PDAs.
Además de eso, las pérdidas por delitos informáticos ascienden a miles de millones de pesos al año lo cual
es un número alarmante si tomamos en cuenta el auge que han tenido los pagos por medios móviles.
Sin embargo, a medida que el poder de cómputo y la memoria varían de un dispositivo a otro también lo
hace el nivel de protección a la que puede acceder. La criptografía juega un papel sumamente importante en
ésta protección por tanto, esta tesis pretende delimitar cual es el mejor algoritmo para implementar en uno
de estos dispositivos y a su vez proponer mejoras en su desempeño y sin sacrificar la seguridad. La premisa
es lograr una mejora sin sacrificar la batería del teléfono ya que ésta es la que debe dar vida a todo el
sistema y su uso debe ser prioritario.
El primer capítulo dará una semblanza histórica a la criptografía y su evolución, así como los tipos de
criptografía existentes y los conceptos básicos que se usaran a lo largo de este documento.
En el segundo capítulo nos centraremos en la criptografía aplicada a los teléfonos celulares, la arquitectura
que estos usan (en su gran mayoría ARM) y sus elementos determinantes.
16 | P á g i n a
Posteriormente, en el tercer capítulo Se analizarán diferentes tipos algoritmos de cifrado y se elegirá aquel
que represente una mejor opción para un teléfono de lo que se le conoce como gama baja-media que
usualmente usan procesadores de arquitectura ARM.
Por último, una vez elegido y probado se procederá, en el cuarto capítulo, a proponer mejoras sobre su
implementación y hacer pruebas básicas que denoten resultados positivos en el algoritmo mejorando el
cálculo y por tanto su velocidad con menos recursos.
17 | P á g i n a
Objetivos
Determinar cuál es el mejor algoritmo criptográfico tomando como base su posibilidad de implementación
en dispositivos móviles y seguridad que este posea. Proponer mejoras en la implementación del mismo para
lograr un balance entre velocidad y consumo energético sin sacrificar la seguridad ni la integridad del
algoritmo con el fin de obtener una adecuada utilidad para el usuario de cómputo móvil.
Objetivos Particulares:
Atender los actuales requerimientos de los dispositivos móviles en cuanto a poder de cómputo y
seguridad se refiere.
Proponer mejoras, en caso de existirlas, para el algoritmo más idóneo elegido por la investigación
de manera que sea aplicable en al menos el 80% de los teléfonos móviles tipo smartphone del
mercado actual, dentro de la arquitectura ARM y pertenecientes a la gama baja-media.
18 | P á g i n a
19 | P á g i n a
CAPITULO I
Fundamentos y Preliminares
En la actualidad la demanda de cómputo móvil ha ido en aumento. Dado que el valor de los datos que se
manejan en dispositivos móviles varía con respecto a cada usuario, es necesario contar con herramientas
eficientes para protegerla, tanto en el dispositivo móvil como cuando se transmite en una red inalámbrica.
En este capítulo se explican algunos conceptos básicos de criptografía y los algoritmos que la constituyen,
las ventajas y desventajas de la criptografía de llave secreta, de la criptografía de llave pública y un
panorama general del proceso de autenticación básica.
1.1 Introducción Histórica
Desde los tiempos más remotos, las personas han utilizado diversos métodos con el fin de lograr que un
mensaje no llegara a manos de personas no autorizadas a leerlo. Algunos de los testimonios más antiguos
sobre la escritura oculta que se conocen se remontan a Heródoto quien hizo una crónica de los conflictos
entre Grecia y Persia en el siglo V a.C. Fue este método el que salvó a Grecia de ser ocupada por Jerjes, Rey
de Reyes persa. [10, 11, 28, 34, 64, 114]
Heródoto cuenta en su crónica que Demarato, un griego exiliado en la ciudad Persa de Susa, tuvo
conocimiento de los preparativos de Jerjes para atacar Grecia y decidió alertar a los espartanos mediante un
mensaje oculto en tablillas de madera. El método de ocultación consistió en retirar la cera de las tablillas,
escribir el mensaje y luego volver a cubrir con cera ocultando de esta manera los planes persas que estaban
escritos debajo de ella.
En los dos mil años que han transcurrido desde Heródoto, diversas formas de ocultación de mensajes han
sido utilizadas por todo el mundo. Por ejemplo, en la China antigua se escribían mensajes sobre seda fina,
que luego era aplastada hasta formar una pelotita diminuta que se recubría de cera. Entonces, el mensajero
se tragaba la bola de cera. En el siglo XV, el científico italiano Giovanni Porta describió una antigua técnica
para esconder mensajes dentro de un huevo cocido haciendo una tinta con una mezcla de una onza de
alumbre y una pinta de vinagre, y luego escribiendo en la cáscara.
La solución penetra a través de la cáscara porosa y deja un mensaje en la superficie del huevo duro, que sólo
se puede leer si se pela el huevo. La ocultación de la información ofrece sin duda un nivel de seguridad, pero
adolece de una debilidad fundamental. Si se descubre el mensaje, el contenido de la comunicación secreta
se revela en el acto, es decir, interceptar el mensaje compromete inmediatamente toda la seguridad. Por
20 | P á g i n a
eso, paralelamente al desarrollo de la ocultación de mensajes, se produjo la evolución de la criptografía,
término derivado de los vocablos griegos “kryptos” que significa oculto y “graphein” que significa escritura.
El objetivo primordial de la criptografía es que si el enemigo intercepta un mensaje cifrado, éste es
ininteligible ya que no se busca ocultar la existencia del mensaje si no de su significado y de esta manera
dotar a la comunicación de seguridad; A éste proceso se le conoce como cifrado.
La criptografía clásica utiliza fundamentalmente técnicas de transposición y sustitución. En la transposición,
las letras del mensaje simplemente se colocan de otra manera, generando así un anagrama. Para que esta
transposición sea efectiva, la combinación de letras necesita seguir un sistema sencillo, establecido
previamente por el emisor y el receptor. Como ejemplo se tiene la transposición de “riel”, en la que el
mensaje se escribe alternando las letras en dos líneas separadas:
Tu secreto es tu prisionero; si lo sueltas, tu eres su prisionero
t s c e o s u r s o e o i i u l a t e e s p i i n r
u e r t e t p i i n r s l s e t s u r s u r s o e o.
Otra forma de transposición es la producida en el primer aparato criptográfico militar de la Historia, la
escítala espartana (siglo V a.C.). Se trata de una vara de madera sobre la que se enrosca una tira de cuero o
pergamino, tal como se muestra en la figura 1.1. El emisor escribe el mensaje a lo largo de la longitud de la
escítala y luego desenrosca la tira, que ahora parece llevar una lista de letras sin sentido. Para recuperar el
mensaje, el receptor simplemente enrosca la tira de cuero en torno a una escítala del mismo diámetro que
el usado por el emisor. La alternativa a la transposición es la sustitución. Una de las descripciones más
antiguas de cifrado por sustitución aparece en el Kamasutra, donde se recomienda a las mujeres que
estudien el arte de la escritura secreta, proponiéndoles emparejar al azar las letras del alfabeto y
posteriormente sustituir cada letra del mensaje original por su pareja. Esta forma de escritura secreta se
conoce como cifrado por sustitución dado que cada letra del texto llano se sustituye por una letra diferente.
La diferencia entre transposición y sustitución radica en la identidad y posición de cada letra, mientras que
en la transposición se cambia la posición manteniendo la identidad, en la sustitución es la identidad la que
varía.
Figura 1-1 Escítala espartana
21 | P á g i n a
El primer uso documentado de un cifrado de sustitución con propósitos militares aparece en La Guerra de
las Galias, de Julio Cesar (año 100-49 a.C.). César utilizó la escritura secreta tan frecuentemente que Valerio
Probo escribió un tratado entero acerca de sus cifrados, que desgraciadamente no ha sobrevivido. Sin
embargo, gracias a la obra de Suetonio, “Vidas de los Césares LVI”, escrita en el siglo II de nuestra era,
tenemos una descripción detallada de uno de los tipos de cifrado de sustitución utilizado por César. El
emperador sencillamente sustituía cada letra del mensaje con la letra que está tres lugares más adelante en
el alfabeto. Este método es llamado “cifrado César”. Aunque Suetonio sólo menciona un cambio del César
de tres lugares, es evidente que al utilizar cualquier cambio de entre 1 y 25 lugares es posible generar 25
cifrados diferentes.
El algoritmo de sustitución tiene la ventaja de su sencillez a la hora de ponerlo en práctica, a su vez ofrece
un alto nivel de seguridad. Esta simplicidad y fortaleza hicieron que el cifrado de sustitución dominara el
arte de la escritura secreta a lo largo del primer milenio de nuestra era.
El gran paso adelante sucedió en Oriente. Los eruditos árabes fueron capaces de encontrar un método para
descifrar la cifra de sustitución mono alfabética, descubriendo que algunas letras son más corrientes que
otras. Esta observación aparentemente inocua conduciría al primer gran avance hacia el criptoanálisis.
Los monjes europeos comenzaron a redescubrir viejas cifras de sustitución, inventaron otras nuevas y
ayudaron a reintroducir la criptografía en la civilización occidental. Así, en el siglo XIV el uso de la
criptografía se había extendido considerablemente.
El primer gran criptoanalista europeo fue Giovanni Soro, nombrado secretario de cifras en Venecia en 1506.
La reputación de Soro se extendió por toda Italia y fueron muchos los mensajes que llegaron a sus manos
para ser descifrados.
Incumbía a los criptógrafos inventar un nuevo cifrado más sólido, algo que pudiese desconcertar a los
criptoanalistas. Dicho cifrado surgió a finales del siglo XVI y su creador fue el polifacético erudito Florentino
León Battista Alberti. Una conversación sobre criptografía incitó a Alberti a escribir un ensayo sobre este
tema, esbozando lo que él consideraba una nueva forma de cifra. Alberti propuso utilizar dos o más
alfabetos cifrados, alternando entre ellos durante el cifrado, confundiendo de esta manera a los potenciales
criptoanalistas (figura 1.2).
22 | P á g i n a
Figura 1-2 Disco de Alberti
A pesar de que Alberti había dado con el avance más significativo en más de mil años, no logró convertirlo
en un sistema plenamente formado. Fueron varios los intelectuales que estudiaron este sistema pero fue
finalmente Blaise de Vigenère, un diplomático francés nacido en 1523, quién dio con un nuevo cifrado,
coherente y poderoso.
Al nuevo método se le conoce como “cifrado de Vigenère” y su fuerza radica en que no utiliza uno, sino 25
alfabetos de cifrado distintos para ocultar un mensaje. El primer paso del cifrado era trazar lo que se
denomina un cuadro Vigenère, tal y como se muestra en la figura 1.3. Se trata de un alfabeto llano seguido
de 25 alfabetos de cifrado, donde cada uno de ellos comienza en la siguiente letra que el anterior. De esta
forma, la línea 1 representa un alfabeto cifrado con un cambio César de una posición, la segunda línea con
un cambio César de dos posiciones, y así sucesivamente. Se puede cifrar cada letra del texto llano según uno
de los 25 alfabetos cifrados.
La gran ventaja de la cifra Vigenère es que resulta inexpugnable para el análisis de frecuencia. El hecho de
que una letra que aparece varias veces en el texto cifrado pueda representar en cada ocasión una letra
diferente del texto llano genera una ambigüedad tremenda para el criptoanalista. La cifra Vigenère
pertenece a una clase conocida como poli alfabética puesto que emplea varios alfabetos en cada mensaje.
23 | P á g i n a
Figura 1-3 Cuadro de Vigenère
Uno de los padres del criptoanálisis del siglo XIX es Charles Babbage, quien descifró el cifrado de Vigenère.
El criptoanálisis de Babbage consistió en buscar secuencias de letras que aparecían más de una vez en el
texto cifrado. Lo más probable es que la misma secuencia de letras del texto llano haya sido cifrada usando
la misma parte de la clave.
Gracias a los avances realizados por Charles Babbage y Friedrich Kasiski, la cifra Vigenère ya no era segura,
por lo que los criptógrafos trataron de diseñar nuevos métodos de cifrado.
Al finalizar la primera guerra mundial, el comandante Joseph Mauborgne, jefe de la investigación
criptográfica del ejército de Estados Unidos, introdujo el concepto de la clave aleatoria. Se trataba de una
clave que no poseía palabras reconocibles, sino letras mezcladas al azar y las utilizó como parte de la cifra
Vigenère para proporcionar un nivel de seguridad sin precedentes. [103-106].
En 1918 el inventor alemán Arthur Scherbius desarrolló una máquina criptográfica denominada Enigma
(figura 1.4) que era esencialmente una versión eléctrica del disco de cifras de Alberti. La forma básica del
invento de Scherbius consiste en tres elementos conectados por cables: un teclado para escribir cada letra
de texto llano, una unidad modificadora que cifra cada letra de texto llano en la correspondiente letra de
texto cifrado y por último un tablero expositor consistente en varias lámparas que indica la letra de texto
cifrado. El invento de Scherbius proporcionó al ejército alemán el sistema criptográfico más seguro del
mundo.
24 | P á g i n a
Figura 1-4 Máquina Enigma
Por ello al estallar la segunda guerra mundial sus comunicaciones estaban protegidas con un nivel de cifrado
sin precedentes. Los estadounidenses y los franceses intentaron abordar el descifrado de la máquina Enigma
pero sus tentativas resultaron infructuosas.
Un alemán, Hans-Thilo Schmidt jefe del personal de cuerpo de señales del ejército, vendió información
secreta sobre Enigma a las potencias extranjeras y gracias a esta traición, los aliados pudieron crear una
réplica exacta de esta máquina. Sin embargo, esto no resultó suficiente para permitirles descifrar mensajes
cifrados por Enigma. Los franceses e ingleses estaban convencidos que era imposible encontrar la clave
requerida para descifrar un mensaje Enigma concreto, por lo que entregaron a sus aliados, los polacos, las
fotografías de los documentos de Schmidt y dejaron la imposible tarea de descifrar Enigma en manos de un
equipo de científicos capitaneados por Rejewski.
La estrategia de Rejewski para atacar Enigma se centró en el hecho de que la repetición es el enemigo de la
seguridad, esta repetición conduce a patrones y es el arma favorita de los criptoanalistas.
Su equipo realizó la tarea de probar cada una de las 105,456 posiciones de los modificadores, catalogando la
longitud de las cadenas generadas por cada una de ellas. Esta tarea requirió un año de labor, pero una vez
recopilados todos los datos, Rejewski finalmente comenzó a descifrar Enigma, ya que podía encontrar la
clave del día antes que acabara el propio día.
Al ir evolucionando la máquina Enigma se buscaban nuevos métodos de criptoanálisis, pero fue Alan Turing
quien identificó el punto más débil de Enigma. Llegó a la conclusión de que había puntales en los
criptogramas que son fragmentos de texto llano. Estos pueden asociarse a fragmentos de texto cifrado lo
25 | P á g i n a
que resultaba una forma extraordinaria de criptoanálisis.
Además de la máquina utilizada para derrotar el cifrado de Enigma (llamada bombes de Turing, figura 1.5),
los británicos desarrollaron otro instrumento de descifrado: Colossus (figura 1.6), utilizado para combatir el
llamado código Lorenz que se empleaba para cifrar las comunicaciones más importantes de la inteligencia
alemana y su funcionamiento era parecido al de la máquina Enigma pero con una complejidad muy
superior.
Figura 1-5 Bombe de Turing
Figura 1-6 Colossus
Colossus junto con los documentos de su diseño fueron destruidos después de la guerra y a todo aquel que
trabajó en este o en cualquier otro proyecto de Bletchley Park se les prohibió dar información. Los planos
del primer PC de la historia se perdieron para siempre. Su lugar fue ocupado por el proyecto ENIAC (figura
1.7), desarrollado en la Universidad de Pensilvana de los Estados Unidos. A partir de entonces los
criptoanalistas comenzaron a utilizar y comprender la potencia que las maquinas proporcionaban para
descifrar cualquier tipo de cifra.
26 | P á g i n a
Figura 1-7 Eniac
En principio, el cifrado con estas grandes máquinas estaba restringido a los gobiernos y al ejército, sin
embargo, una serie de avances científicos y tecnológicos durante las siguientes décadas, permitieron que
este cifrado por PC fuera asequible para el público en general.
Durante la década de 1970 se produjo el primer microprocesador y con él sobrevino una nueva generación
de máquinas más pequeñas y que podían ser operadas por una sola persona: Las computadoras personales.
Éstas, con el paso de los años, bajaron de precio y se comercializaron en mayor número. Numerosas
empresas comenzaron a utilizarlas para cifrar sus mensajes privados, lo que creó un nuevo problema: la
estandarización. Una compañía podía usar un sistema de cifrado en particular para garantizar la seguridad
de sus comunicaciones internas, pero no podía enviar un mensaje oculto a una organización externa a no
ser que el receptor usara el mismo sistema de cifrado. Finalmente, el 15 de mayo de 1973, la Oficina
Nacional de Estándares norteamericana planeó resolver el problema y solicitó propuestas de cifrado
estándar que permitieran a las empresas comunicarse entre sí. El 23 de noviembre de 1976 se adoptó un
estándar de cifrado con una longitud de clave de 56 bits, dándole el nombre de DES [88]. Superado el
problema de la estandarización, se planteó una nueva dificultad: un método seguro de distribución de
claves.
Fueron Whitfield Diffie y Martin Hellman [36, 35] quienes iniciaron el camino hacia la resolución de este
problema. En la primavera de 1976 Hellman presentó una estrategia para el problema de la distribución de
claves. Demostró que el emisor y el receptor podían acordar una clave sin necesidad de reunirse,
deshaciendo así un axioma que había durado siglos. La idea de Hellman se basaba en una función
unidireccional de la forma IndG (y) = x(mod P). Había conseguido invalidar uno de los axiomas menos
cuestionados de la criptografía y ahora solo se necesitaba que otro perfeccionara el sistema de distribución
de claves para hacerlo más eficaz.
Paralelamente al trabajo de Hellman, Diffie había estado probando otro tipo de enfoque para la resolución
del problema de distribución de claves. Descubrió un nuevo tipo de cifra: la clave asimétrica. Hasta ese
momento las técnicas de cifrado utilizadas habían sido simétricas, es decir, tanto el emisor y el receptor
27 | P á g i n a
utilizaban la misma clave para cifrar y descifrar el mensaje. Sin embargo, en un sistema de clave asimétrica,
la clave de cifrado y la de descifrado no son idénticas. Fueron tres investigadores del laboratorio de
informática del MIT (Massachussets Institute of Technology), Ronald Rivest, Adi Shamir y Leonard Adleman,
quienes consiguieron encontrar una función que convirtiera la teoría de la clave pública en un instrumento
práctico y eficaz. Este sistema se denomina RSA en honor a sus tres descubridores Rivest, Shamir y Adleman
[103].
En 1984 T. ElGamal creó otro criptosistema cuya seguridad se basa en una función unidireccional
denominada logaritmo discreto, que todavía no ha podido resolverse de forma eficiente [37].
Las matemáticas proporcionan las herramientas adecuadas para la creación de algoritmos de ocultación de
información. Así, algunas de las áreas de las matemáticas que se han usado (y se usan) para crear
criptosistemas [18] son:
1. En 1970 R. J. McEliece desarrolló un criptosistema de clave pública basado en códigos detectores -
correctores de errores [78, 79].
2. En los años 80 V. Varadharajan propuso distintas estructuras de anillos que pueden ser aplicados en
la generalización del sistema RSA [92].
3. En 1984 Lidl y Müller proponen polinomios de permutación [73].
4. En 1985, de forma independiente V. Miller [84] y N. Koblitz [67,68] usan la teoría de curvas elípticas
para crear criptosistemas. Estas curvas fueron propuestas por Lenstra para factorizar números
enteros.
5. En 1988 J. Buchmann y H. Williams proponen usar campos cuadráticos reales e imaginarios [25,
107].
6. En 1995 R. Scheidler y H. Williams usan campos ciclotómicos [108].
Por último, existe otro tipo de protocolos que usa la teoría de incertidumbre y se le conoce como
criptografía cuántica [14, 19, 17].
28 | P á g i n a
1.2 Conceptos Básicos
1.2.1 Seguridad de la información
Hay muchas formas de clasificar los servicios y mecanismos que proporcionan seguridad a los sistemas
informáticos. Una de las clasificaciones que más se utilizan es la que se recoge en el estándar internacional
“ISO 7498-2, Arquitectura de Seguridad”, cuyas definiciones y términos se han extendido ampliamente.
Desde el punto de vista de esta norma, los servicios de seguridad son:
(a) Autenticación. Es la identificación ante un sistema, subsistema, red o aplicación, mediante algún
mecanismo o combinación de mecanismos. Una vez que una entidad se ha autenticado puede que necesite
volver a autenticarse para otros fines.
Algunos mecanismos de autenticación son:
Nombre de usuario y contraseña.
Tickets de acceso.
Certificados digitales.
Tarjetas inteligentes
Tokens (Fichas).
Dispositivos biométricos.
(b) Control de acceso. Protege contra el uso no autorizado de recursos. Generalmente, hay un orden
implícito, según el cual una entidad primero se identifica y autentifica y a continuación se le proporciona el
acceso o se le niega, basándose en mecanismos de control de acceso asociados a las credenciales de la
entidad. Cada entidad tiene sus permisos de acceso a cada recurso especificado.
Ejemplos de dichos mecanismos son:
Listas de control de acceso.
Etiquetas de seguridad.
Roles.
Barreras físicas.
Firewalls.
29 | P á g i n a
(c) Confidencialidad. Consiste en proteger los datos trasmitidos o almacenados de difusiones no
autorizadas. Este aspecto de la seguridad se ha vuelto cada vez más importante puesto que cada vez mayor
cantidad de información se trasmite sobre redes inseguras y cada vez mayor volumen de información
sensible llega a los equipos menos protegidos de una red. Se debe asumir que la red no es fiable y que la
información trasmitida puede ser interceptada. En la actualidad el cifrado de la información es la principal
herramienta utilizada para conseguir la confidencialidad.
(d) Integridad de Datos. Consiste en detectar cuando los datos almacenados o trasmitidos han sido
modificados, borrados o reproducidos.
(e) No rechazo. Consiste en asociar la identidad de un individuo con su participación en un proceso. Los
mecanismos de no rechazo proporcionan pruebas de un intercambio digital significativo de algún tipo.
(f) Gestión. Consiste en la administración y gestión de los mecanismos asociados con las categorías de
seguridad.
1.2.2 Criptografía
La palabra criptología proviene de las palabras griegas Krypto y Logos, y significa estudio de lo oculto. Una
rama de de la criptología es la criptografía (Kryptos y Graphos que significa descripción), que se ocupa del
cifrado de mensajes. Esta se basa en que el emisor emite un mensaje en claro, que es tratado mediante un
cifrador con la ayuda de una clave, para crear un texto cifrado. Este texto cifrado, por medio de un canal de
comunicación establecido, llega al descifrador que apoyándose en diversos métodos como veremos más
adelante, extrae el texto original.
Una definición básica para la criptografía se puede encontrar En el libro “Aplicaciones criptográficas” de la
Universidad de Madrid, la cual plantea que es la ciencia que estudia los métodos y procedimientos para
modificar los datos, con objeto de alcanzar las características de seguridad.1
Las principales características que un sistema de seguridad quiere obtener son:
Confidencialidad. Consiste en verificar que sólo las personas autorizadas tienen acceso a la
información.
1 “Aplicaciones Criptográficas” segunda edición de junio de 1999, ISBN 83-87238-57-2, publicado por el departamento de Publicaciones
de la Escuela Universitaria de Informática de la Universidad Politécnica de Madrid, España.
30 | P á g i n a
Integridad. Consiste en garantizar que el documento original no ha sido modificado. El documento
puede ser tanto público como confidencial.
Autenticación. Permite garantizar la identidad del autor de la información.
Según explica Jorge Ramió Aguirre en su libro “Cifrado de comunicaciones digitales”2 la criptografía es:
“Rama inicial de las Matemáticas y en la actualidad de la Informática y la Telemática, que hace uso de
métodos y técnicas con el objeto principal de cifrar y/o proteger un mensaje o archivo por medio de un
algoritmo, usando una o más claves. Esto da lugar a diferentes tipos de sistemas de cifra que permiten
asegurar estos cuatro aspectos de la seguridad informática: la confidencialidad, la integridad, la
disponibilidad y el no repudio de emisor y receptor.”
Que como podemos pensar es una descripción mucho más acertada que la que nos podemos encontrar en
muchos libros, así como la definición que nos hace la Real Academia de la Lengua RAE.
La palabra criptografía sólo hace referencia al uso de códigos, por lo que no engloba las técnicas que se usan
para romper dichos códigos, conocidas como criptoanálisis. Las dos disciplinas están íntimamente ligadas y
al conjunto de ambas y se le conoce con el nombre de criptología.
La criptografía hace años que dejó de ser un arte para convertirse en una técnica o más bien un
conglomerado de técnicas, que tratan sobre la protección de la información (figura 1.8). Entre las disciplinas
que engloba cabe destacar a la Teoría de la Información, la Teoría de Números y la complejidad algorítmica.
Existen dos trabajos fundamentales sobre los que se apoya prácticamente toda la teoría criptográfica actual.
Uno de ellos, desarrollado por Claude Shannon en sus artículos “A Mathematical Theory of Communication”
[111] y “Communication Theory of Secrecy Systems” [112], sienta las bases de la teoría de la información y
de la criptografía moderna. A partir de entonces la criptografía alcanza nuevos horizontes. El segundo
trabajo, desarrollado en el artículo “New directions in Cryptography” [35] por Whitfield Diffie y Martin
Hellman en 1976, introduce el concepto de criptografía asimétrica, abriendo enormemente el abanico de
aplicación de esta disciplina.
2 ”Cifrado de las comunicaciones digitales” Jorge Ramió Aguirre 2006
31 | P á g i n a
Figura 1-8 Criptografía
Existen diversos algoritmos matemáticos que intentan cubrir una o varias de estas características básicas de
seguridad. El nivel de cumplimiento de sus objetivos es difícil de evaluar, ya que diversos algoritmos pueden
ser vulnerables ante técnicas de ataque diferentes, además la mayoría de los algoritmos pueden trabajar
con claves de distinta longitud lo cual afecta directamente a la robustez. Por otro lado, existen otras
características, a parte de la robustez del algoritmo, que también influyen en el proceso de selección del
algoritmo más apropiado para una determinada aplicación. Algunas de estas características son: el tiempo
de cálculo del proceso de cifrado, el tiempo de cálculo del proceso de descifrado, la relación de tamaño
entre el documento original y el documento cifrado, etc.
Los algoritmos más conocidos son los que obtienen un documento a partir de un documento original al
aplicar un algoritmo que utiliza una clave secreta como argumento. En general los algoritmos criptográficos
se pueden clasificar en tres grandes familias:
Criptografía de clave secreta o criptografía simétrica.
Criptografía de clave pública o criptografía asimétrica.
Algoritmos HASH o de resumen.
1.2.3 Criptosistemas
Se define un criptosistema como una quíntupla (M, C, K, E, D), donde:
M representa el conjunto de todos los mensajes sin cifrar (lo que se denomina texto claro o plaintext) que
pueden ser enviados. Son componentes de un mensaje inteligible (bits, bytes, pixels, signos, caracteres, etc.)
que provienen de un alfabeto previamente establecido. Este lenguaje tiene unas reglas sintácticas y
semánticas y en algunos casos (sistemas de cifrado clásicos) la longitud del alfabeto indicará el módulo en el
cual se trabaja. En los modernos, no guarda relación.
32 | P á g i n a
Además, hay mensajes con sentido y mensajes sin sentido
M = {m1, m2, m3, . . . , mn}.
C representa el conjunto de todos los posibles mensajes cifrados, o criptogramas. Normalmente el alfabeto
es el mismo que el utilizado para crear el mensaje en claro. Además, se supone que el espacio de los textos
cifrados C y el espacio de los mensajes M (con y sin sentido) tienen igual magnitud y, en este caso, a
diferencia del espacio de mensajes M, son válidos todo tipo de criptogramas,
C = {c1, c2, c3, . . . , cn}.
K representa el conjunto de claves que se pueden emplear en el sistema criptográfico. Se supone que es un
conjunto altamente aleatorio de caracteres, palabras, bits, bytes, etc., en función del sistema de cifra. Al
menos una de las claves en un criptosistema se guarda en secreto,
K = {k1, k2, k3, . . . , kn}.
E es el conjunto de transformaciones de cifrado o familia de funciones que se aplica a cada elemento de M
para obtener un elemento de C. Existe una transformación diferente Ek para cada valor posible de la clave k.
Es decir, Ek es una aplicación (con una clave k que está en el espacio de claves K) de M en C:
Ek: M → C con k ∈ K.
En general el algoritmo de cifrado es de dominio público.
D es el conjunto de transformaciones de descifrado, análogo a E. En este caso, Dk es una aplicación con una
clave k (en el espacio de claves K) de C en M . Se utiliza el concepto de inverso. En consecuencia Dk es la
operación inversa de Ek o bien, se utiliza la misma transformación Ek para descifrar pero con una clave k0 que
es la inversa de k dentro de un cuerpo,
Dk: C → M con k ∈ K.
Todo criptosistema debe cumplir la siguiente condición:
Dk(Ek(m)) = m,
Es decir, dado un mensaje en claro m, si se cifra empleando la clave k y luego se descifra empleando la
misma clave, se obtiene el mensaje original m.
Existen dos tipos fundamentales de criptosistemas:
(a) Criptosistemas simétricos o de clave privada: Son aquellos que emplean la misma clave k tanto para
33 | P á g i n a
cifrar como para descifrar. Presentan el inconveniente de que para ser empleados en comunicaciones, la
clave k debe ser conocida tanto por el emisor como por el receptor, lo cual plantea el problema de
transmitir la clave de forma segura.
(b) Criptosistemas asimétricos o de clave pública: Son aquellos que emplean una doble clave (kp, kP). La
clave kp se conoce como clave privada y se emplea para la transformación de descifrado D, mientras que kP
se conoce como clave pública y sirve para el cifrado E.
En la práctica se emplea una combinación de estos dos tipos de criptosistemas, debido a que los asimétricos
presentan el inconveniente de ser computacionalmente más costosos que los simétricos los cuales suelen
ser muy eficientes en mensajes largos; luego se hace uso de la criptografía asimétrica para cifrar las claves
simétricas (cortas).
1.2.4 Criptoanálisis
El criptoanálisis se define como la ciencia del descifrado de los criptogramas por análisis y deducción, sin
tener conocimiento previo de la clave. No se considera criptoanálisis el descubrimiento de un algoritmo
secreto de cifrado; se supone, por el contrario, qué los algoritmos siempre son conocidos.
El criptoanálisis se realiza estudiando grandes cantidades de pares (mensaje, criptograma) generados con la
misma clave. El mecanismo que se emplea para obtener estos pares es indiferente y puede ser resultado de
escuchar un canal de comunicaciones o puede ser que el objeto de ataque responda con un criptograma
cuando se le envíe un mensaje, o que se tenga acceso al dispositivo de cifrado y éste permita efectuar
operaciones pero no permita leer su clave (por ejemplo, las tarjetas de los teléfonos móviles GSM). Cuando
el sistema es débil, pueden ser suficientes unos cientos de mensajes para obtener información que permita
deducir la clave empleada.
Como el algoritmo de cifrado es conocido, se puede intentar criptoanalizar un sistema aplicando para cada
una de las claves el algoritmo de descifrado hasta encontrar una salida que tenga sentido como posible
texto claro. Este tipo de técnicas que buscan exhaustivamente en todo el espacio de claves K, se denominan
“fuerza bruta” y no se consideran como auténticas técnicas de criptoanálisis, reservándose este término
para mecanismos que explotan posibles debilidades intrínsecas en el algoritmo de cifrado. Se denomina
ataque a cualquier técnica que permite recuperar un mensaje cifrado empleando menos esfuerzo
computacional que el que se utiliza por fuerza bruta.
En cualquier criptosistema digno de interés el espacio de claves es lo suficientemente grande como para
que los métodos basados en fuerza bruta sean inviables. No obstante, hay que tener en cuenta que la
capacidad de cálculo de las computadoras crece a gran velocidad, por lo que algoritmos que hace unos años
34 | P á g i n a
eran resistentes a ataques por fuerza bruta hoy pueden resultar inseguros. A pesar de eso, existen
longitudes de clave para las que resulta imposible, empleando la computación actual, tener éxito al aplicar
un método de este tipo.
Dos métodos de criptoanálisis simétrico que proporcionan resultados interesantes son el análisis diferencial
y el análisis lineal. El primero de ellos, parte de pares de mensajes con diferencias mínimas (usualmente de
un bit), estudia las variaciones que existen entre los mensajes cifrados correspondientes y trata de
identificar patrones comunes. El segundo emplea operaciones XOR entre algunos bits del texto claro y
algunos bits del texto cifrado, obteniendo finalmente un único bit. Si se realiza esto con muchos pares (texto
claro, texto cifrado) se puede obtener una probabilidad en ese bit que se calcula y si está suficientemente
sesgada (no se aproxima a 1 ) se tiene posibilidad de que la clave sea recuperada.
Un tipo de análisis para algoritmos asimétricos consiste en deducir la clave privada a partir de la pública. Por
lo general, se suelen emplear técnicas analíticas que intentan resolver los problemas de elevado coste
computacional (factorización, logaritmos discretos, etc) en los que se apoyan estos criptosistemas. Mientras
estos problemas permanezcan sin resolver de forma eficiente se puede seguir confiando en estos
algoritmos. La gran variedad de sistemas criptográficos existentes produce necesariamente una gran
variedad de técnicas de criptoanálisis, cada una de ellas asociada a un algoritmo o familia de ellos.
1.3 Criptografía de clave secreta
En este tipo de criptografía se incluyen el conjunto de algoritmos diseñados para cifrar un mensaje
utilizando una única clave conocida por los dos interlocutores, de manera que el documento cifrado sólo
pueda descifrarse conociendo dicha clave secreta. Algunas de las características más destacadas de este tipo
de algoritmos son las siguientes:
A partir del mensaje cifrado no se puede obtener el mensaje original ni la clave que se ha
utilizando, aunque se conozcan todos los detalles del algoritmo criptográfico utilizado.3
Se utiliza la misma clave para cifrar el mensaje original que para descifrar el mensaje codificado.
Emisor y receptor deben haber acordar una clave común por medio de un canal de comunicación
confidencial antes de poder intercambiar información confidencial por un canal de comunicación
inseguro.
3 Hay que tener en cuenta que la mayoría de los algoritmos de cifrado son públicos, ya que la seguridad reside en el diseño del propio
algoritmo.
35 | P á g i n a
El esquema general de cifrado y descifrado mediante algoritmos de clave privada se muestra en la figura 1.9.
A partir de un documento original se obtiene un documento cifrado al aplicar una clave secreta; esa misma
clave secreta se utiliza posteriormente para volver a obtener el documento original.
Figura 1-9 Esquema de los algoritmos de clave secreta
Los algoritmos simétricos más conocidos son: DES, 3DES, RC2, RC4, RC5, IDEA, Blowfish y AES.
El algoritmo DES4 basado en Lucifer de IBM (1975), fue seleccionado como algoritmo estándar de cifrado en
1977 por NIST (National Institute of Standards and Technology, USA). Utiliza claves de cifrado bastante
cortas (56 bits, de los cuales sólo se utilizan 48 bits) y hoy en día se considera poco robusto, sobre todo
desde que en 1998 la Electronica Frontier Foundation hizo público un crackeador de código DES capaz de
descifrar mensajes DES en menos de 3 días.
El algoritmo 3DES5, desarrollado por Tuchman en 1978, es una manera de mejorar la robustez del algoritmo
DES que consiste en aplicarlo tres veces consecutivas. Se puede aplicar con la misma clave cada vez, o con
claves distintas y combinando el algoritmo de cifrado con el de descifrado, lo cual da lugar a DES-EEE3, DES-
EDE3, DES-EEE2 y DES-EDE2. El resultado es un algoritmo seguro y que se utiliza en la actualidad, aunque
resulta muy lento comparado con otros algoritmos más modernos que también son seguros.
En 1989, Ron Rivest desarrolló el algoritmo RC2 (Rivest’s Cipher) para RSA Data security, Inc6 . Se trata de un
algoritmo de cifrado por bloques, que utiliza una clave de tamaño variable. Es de dos a tres veces más
rápido que el algoritmo DES, siendo más seguro7
4 National Bureau of Standards, Data Encryption Standard,FIPS-Pub.46. National Bureau of Standards, U.S. Department of Com-
merce,Washington D.C., Jan 1977. 5 National Bureau of Standards, Data Encryption Standard, FIPS-Pub.46-3. National Bureau of Standards, U.S. Department of Com-
merce,Washington D.C., Oct 1999. 6 Lars R. Knudsen,Vincent Rijmen, Ronald L. Rivest, and M.J.B. Robshaw: “On the Design and Security of RC2”, Proceedings Fifth Fast
Software Encryption Workshop FSE’98, pages 206—221, (1998). 7 (http://theory.lcs.mit.edu/~rivest/).
36 | P á g i n a
Ron Rivest desarrolló el algoritmo RC4 en 1987 para RSA Data Security, que se hizo público en 1994 8 . Se
considera inmune al criptoanálisis diferencial y lineal. Es el algoritmo utilizado en el cifrado WEP de la
mayoría de los puntos de acceso WiFi. Es necesario comentar que el protocolo WEP se considera vulnerable,
pero no por problemas con el algoritmo de cifrado RC4 sino por otros aspectos del propio protocolo que
permiten determinar la clave de cifrado en un tiempo corto (pocas horas en una red con mucho tráfico).
Otro algoritmo de Ron Rivest es RC5, publicado en 19949. Se trata de un algoritmo de cifrado por bloques,
que utiliza claves de tamaño variable. Se caracteriza por la sencillez del algoritmo, que lo hacen muy rápido
y fácil de implementar tanto en software como en hardware.
International Data Encription Algorithm, IDEA, diseñado por Xuejia Lai y James L. Massey de ETH-Zürich. Es
un algoritmo de cifrado por bloques de 64 bits que emplea claves de 128 bits, que se presentó por primera
vez en 199110. Es dos veces más rápido que DES, a pesar de utilizar claves mucho más largas. Es un
algoritmo patentado en algunos países (entre ellos España), salvo para usos no comerciales.
Blowfish es un algoritmo de cifrado por bloques de 64 bits diseñado por Bruce Schneier en 199311. Utiliza
claves de longitud variable entre 32 y 448 bits. A pesar de utilizar un tamaño de bloque pequeño, que podría
facilitar su vulnerabilidad al procesar textos largos, se considera un algoritmo seguro y es más rápido que
DES.
Twofish es una variante de Blowfish que utiliza bloques de 128 bits y claves de 256 bits12. También diseñado
por Bruce Schneier, en colaboración con John Kelsey, Doug Whiting, David Wagner, Chris Hall, y Niels
Ferguson, fue uno de los cinco finalistas en el proceso de selección de NIST para sustituir a DES como
algoritmo estándar.
Advanced Encryption Standar (AES) es el estándar para cifrado simétrico del NIST desde el 26 de mayo de
2002 en sustitución de DES. AES también es conocido como “Rijndael”, nombre original del algoritmo
propuesto en 199913 que cambió al ser seleccionado por NIST. Fue desarrollado por dos criptógrafos Belgas,
Joan Daemen y Vincent Rijmen. Es un algoritmo de cifrado por bloques con longitud de bloque y longitud de
clave variables. Los valores adoptados para el estándar son bloques de 128 bits, y claves de longitud 128,
8 R.L. Rivest: “The RC4 Encryption Algorithm”. RSA Data. Security, Inc., Mar 12th, 1992
9 Ronald L. Rivest: “The RC5 Encryption Algorithm”, Proceedings of the 1994 Leuven Workshop on Fast Software Encryption, pages 86-96.
(Springer 1995). 10 Xuejia Lai, James L. Massey: “A Proposal for a New Block Encryption Standard”, EUROCRYPT 1990. Workshop on the Theory and Appli-
cation of Cryptographic Techniques, Aarhus, Denmark, May 1990, pp389–404. 11
B. Schneier: “Description of a New Variable-Length Key, 64-Bit Block Cipher (Blowfish)”, Fast Software Encryption, Cambridge Security
Workshop Proceedings (December 1993), Springer-Verlag, 1994, pp. 191-204. 12
B. Schneier, J. Kelsey, D. Whiting, D.Wagner, C. Hall, N. Ferguson: “Twofish: A 128-Bit Block Cipher”, Jun 1998.
http://www.schneier.com/paper-twofish-paper.html. 13
Joan Daemen,Vincent Rijmen: “The Rijndael BlockCipher”, sep 1999. http://csrc.nist.gov/CryptoToolkit/aes/rijndael/Rijndael.pdf.
37 | P á g i n a
192 ó 256 bits14.
La recomendación general es utilizar el algoritmo AES, ya que fue cuidadosamente analizado durante el
proceso de selección desarrollado por NIST y se considera muy bueno. Además, al convertirse en el estándar
se ha extendido muchísimo y seguramente se ha convertido en el algoritmo que más criptoanálisis ha
experimentado lo que demuestra su robustez.
1.3.1 Cifrado de bloques
En Criptografía, una unidad de cifrado por bloques (block cipher en inglés) es una unidad de cifrado de clave
simétrica que opera en grupos de bits de longitud fija, llamados bloques, aplicándoles una transformación
invariante. Cuando realiza cifrado, una unidad de cifrado por bloques toma un bloque de texto plano o claro
como entrada y produce un bloque de igual tamaño de texto cifrado. La transformación exacta es controlada
utilizando una segunda entrada — la clave secreta. El descifrado es similar: se ingresan bloques de texto
cifrado y se producen bloques de texto plano.
Las unidades de cifrado por bloques se diferencian de las unidades de flujo de cifrado en que un flujo de
cifrado trabaja sobre dígitos individuales, uno después del otro, y la transformación varía durante el proceso
de cifrado. La diferencia entre los dos tipos de unidades es algo difusa, dado que una unidad de cifrado por
bloques puede ser operada en un modo que permite utilizarla como una unidad de flujo de cifrado, donde
en lugar de dígitos se opera con bloques.
1.3.2 Cifrado de Flujo
Los cifradores de flujo son algoritmos de cifrado que pueden realizar el cifrado incrementalmente,
convirtiendo el texto en claro en texto cifrado bit a bit. Esto se logra construyendo un generador de flujo de
clave. Un flujo de clave es una secuencia de bits de tamaño arbitrario que puede emplearse para oscurecer
los contenidos de un flujo de datos combinando el flujo de clave con el flujo de datos mediante la función
XOR. Si el flujo de clave es seguro, el flujo de datos cifrados también lo será.
Se puede construir un generador de flujo de clave iterando una función matemática sobre un rango de
valores de entrada para producir un flujo continuo de valores de salida. Los valores de salida se concatenan
entonces para construir bloques de texto en claro, y los bloques se cifran empleando una clave compartida
por el emisor y el receptor.
14 National Bureau of Standards, Data Encryption Standard, FIPS-Pub.197. National Bureau of Standards, U.S. Department of Com-
merce,Washington D.C.,Nov. 2001.
38 | P á g i n a
Para conservar la calidad de servicio del flujo de datos, los bloques del flujo de clave deberían producirse
con un poco de antelación sobre el momento en que vayan a ser empleados, además el proceso que los
produce no debiera exigir demasiado esfuerzo de procesamiento como para retrasar el flujo de datos.
1.4 Criptografía de clave pública
Esta categoría incluye un conjunto de algoritmos criptográficos que utilizan dos claves distintas para cifrar y
para descifrar el mensaje. Ambas claves tienen una relación matemática entre sí, pero la seguridad de esta
técnica se basa en que el conocimiento de una de las claves no permite descubrir cuál es la otra clave. En
realidad sería necesario conocer todos los números primos grandes para ser capaz de deducir una clave a
partir de otra, pero está demostrado que en la práctica se tardarían demasiados años sólo en el proceso de
obtención de los número primos grandes.
Cada usuario cuenta con una pareja de claves, una la mantiene en secreto y se denomina clave privada y
otra la distribuye libremente y se denomina clave pública. Para enviar un mensaje confidencial sólo hace
falta conocer la clave pública del destinatario y cifrar en mensaje utilizando dicha clave. En este caso los
algoritmos asimétricos garantizan que el mensaje original sólo pueda recuperarse utilizando la clave privada
del destinatario. Dado que la clave privada se mantiene en secreto, sólo el destinatario podrá descifrar el
mensaje.
Figura 1-10 Esquema de algoritmos de clave pública
Estos algoritmos pueden trabajar indistintamente con cualquiera de las claves, de manera que un mensaje
cifrado con la clave pública sólo puede descifrarse con la clave privada, pero cualquier mensaje cifrado con
la clave privada sólo puede ser descifrado con la clave pública. Esta característica permite utilizar este
método para otras aplicaciones además de las que sólo requieren confidencialidad, como es el caso de la
firma electrónica.
39 | P á g i n a
Algunas de las características más destacadas de este tipo de algoritmos son las siguientes:
Se utilizan una pareja de claves denominadas clave pública y clave privada, pero a partir de la clave
pública no es posible descubrir la clave privada.
A partir del mensaje cifrado no se puede obtener el mensaje original, aunque se conozcan todos los
detalles del algoritmo criptográfico utilizado y aunque se conozca la clave pública utilizada para
cifrarlo.
Emisor y receptor no requieren establecer ningún acuerdo sobre la clave a utilizar. El emisor se
limita a obtener una copia de la clave pública del receptor, lo cual se puede realizar, en principio,
por cualquier medio de comunicación aunque sea inseguro.
A diferencia de los algoritmos de clave secreta, que existen desde los tiempos de los romanos, los métodos
asimétricos son muy recientes. En la década de 1970 se publicó el primer algoritmo asimétrico completo,
denominado RSA, que sigue siendo el más utilizado en la actualidad15. La seguridad de este algoritmo reside
en la dificultad que supone la factorización de un número compuesto por factores primos muy grandes. Si
un criptoanalista fuera capaz de encontrar los factores primos sería capaz también de determinar la clave
privada y, por lo tanto, descifrar el mensaje. Sin embargo el problema de factorización se considera costoso,
computacionalmente hablando, de resolver en la práctica, y cuanto más grande sean los números utilizados,
es decir las longitudes de las claves, mayor dificultad se alcanza.
1.5 Algoritmos HASH o de resumen
Los algoritmos HASH, parten de una información de entrada de longitud indeterminada y obtienen como
salida un código, que en cierto modo se puede considerar único para cada entrada. La función de estos
algoritmos es determinista, es decir que partiendo de una misma entrada siempre se obtiene la misma
salida. Sin embargo, el interés de estos algoritmos reside en que partiendo de entradas distintas se obtienen
salidas distintas.
Unos ejemplos muy sencillos, aunque muy vulnerables, son los dígitos de control y los CRC (Cyclic
Redundancy Code) que se utilizan para detectar errores de trascripción o de comunicación. Estos algoritmos
en particular garantizan que el código generado cambia ante una mínima modificación de la entrada y
tienen aplicaciones muy concretas de control de integridad en procesos con perturbaciones poco probables.
Sin embargo son poco robustos y está demostrado que se pueden realizar pequeños conjuntos de
15 R. Rivest, A. Shamir, L.Adleman:“A Method for ObtainingDigital Signatures and Public-Key Cryptosystems”.Communications of the
ACM,Vol. 21 (2),pp.120–126. 1978. Previously released
40 | P á g i n a
modificaciones en un documento de manera que el CRC resulte inalterado. En un buen algoritmo HASH es
inadmisible que un conjunto reducido de modificaciones no altere el código resultante, ya que se podrían
hacer retoques en el documento sin que fuesen detectados, y por lo tanto no garantiza la integridad. Dado
que el tamaño del código que se genera como salida es de tamaño limitado, (típicamente 128, 256 ó 512
bits) mientras que el tamaño del documento de entrada es ilimitado (típicamente un archivo), es evidente
que se cumplen dos propiedades:
El algoritmo es irreversible, es decir, no es posible obtener el documento original a partir del código
generado.
Existen varios documentos que dan lugar a un mismo código.
La segunda propiedad es debida a que el número de combinaciones de los códigos de tamaño limitado es
menor al número de combinaciones de cualquier archivo grande. Sin embargo los buenos algoritmos
consiguen que los documentos que dan lugar al mismo código, sean completamente diferentes y por lo
tanto sólo uno de ellos será legible.
Los algoritmos más utilizados son MD5 y SHA1, pero nunca se utilizan códigos CRC en aplicaciones de
seguridad. Por ejemplo, los certificados incluyen un campo llamado fingerprint con el resultado de los
algoritmos MD5 y SHA1.
NIST presentó en 1993 un algoritmo basado en las mismas técnicas que MD5 y denominado SHA (Secure
Hash Algorithm). Este algoritmo fue declarado estándar Federal Information Processing Standard PUB 180
en 1993, pero en 1995 la Agencia de Seguridad Nacional (NSA) lo sustituyó por una versión mejorada que
actualmente se conoce como SHA-1 y que se considera más seguro que MD5. Produce un código hash de
160 bits para mensajes de longitud máxima 264 bits, aunque existen otras variantes poco utilizadas todavía
que producen códigos de mayor longitud.
En general, SHA1 se considera el mejor algoritmo de esta familia y es el que se aplica en la mayoría de las
aplicaciones de firma electrónica. Por lo tanto es muy habitual aplicar SHA1 seguido de RSA para realizar una
firma electrónica de un documento, o bien el algoritmo DSA específico para firma electrónica que también
utiliza SHA1 internamente.
Por otro lado, el algoritmo MD5 (Message-Digest Algorithm 5) es un algoritmo que produce un código de
128 bits. Fue creado por Ron Rivest en 1991 y se convirtió en el estándar de Internet RFC 1321.
Recientemente se han encontrado pequeñas vulnerabilidades en este algoritmo que sugieren un
movimiento hacia SHA1.
Digital Signature Algorithm (DSA) es el estándar de United States Federal Government para firma digital. Su
desarrollo se atribuye a David W. Kravitz, de la National Security Agency. Fue presentado por NIST en agosto
41 | P á g i n a
de 1991, adoptado como estándar en 1993, y con última revisión de 200016. Es un algoritmo exclusivo de
firma electrónica basado en clave pública, pero no vale para comunicaciones confidenciales.
1.6 Comparativa entre algoritmos Simétricos y asimétricos
Una vez definidos los conceptos de criptografía asimétrica y simétrica, se procederá a resumir sus ventajas y
desventajas mencionando los algoritmos más usados en cada una de ellas de manera que sea más clara su
importancia.
Tabla 1-1 Comparativa entre criptografía simétrica y asimétrica
Ventajas Desventajas Algoritmos más usados
Simétrica
Sistema eficiente en grupos muy reducidos, ya que sólo es necesaria una única clave
Es necesario compartir la clave entre emisor y receptor por medios que pueden no ser seguros
· DES con tamaño de clave de 56 bits
No es necesario disponer de una tercera parte confiable
Si se compromete la clave, se compromete toda la comunicación
· Triple-Descon tamaño de clave de 128 bits a 256 bits
Infraestructura sencilla No permite autenticar al emisor ya que una misma clave la utilizan dos personas
· Blowfish con tamaño de clave de 128 bits a 256 bits
Se necesita un elevado número de claves: n*(n-1)/2; siendo n el número de personas implicadas en una comunicación cifrada
· AES con tamaños de clave de 128, 192 o 256 bits
Asimétrica
Número de claves reducido, ya que cada individuo necesitará únicamente un par de claves
Alto coste computacional en el proceso de generación de claves
RSA con tamaño de clave mayor o igual a 1024 bits
16 National Bureau of Standards, Data Encryption Standard, FIPS-Pub.186-2. National Bureau of Standards, U.S. Department of Com-
merce,Washington D.C., 2000.
42 | P á g i n a
La necesidad de un tercero (autoridad de certificación) en el proceso
DSA con tamaño de clave de 512 bits a 1024 bits
No es necesario transmitir la clave privada entre emisor y receptor
Necesidad de una gran infraestructura independientemente del número de individuos. Se precisa mayor tiempo de proceso y claves más grandes
ElGamal con tamaño de clave comprendida entre los 1024 bits y los 2048 bits
Permite autenticar a quien utilice la clave privada
43 | P á g i n a
44 | P á g i n a
CAPITULO II
Criptografía en arquitecturas móviles y su
programación
2.1 Seguridad en Telefonía Móvil
La telefonía móvil se caracteriza por ser un sistema de comunicación ampliamente difundido debido a su
fácil acceso, conectividad y versatilidad. Los teléfonos inteligentes (smartphones) cuentan con sistemas
operativos similares a una PC, y tienen la ventaja del uso de redes geográficamente distribuidas a nivel
global. Sin embargo, esto incrementa las posibilidades de explotación de las vulnerabilidades que puedan
existir en ellos.
2.1.1 El móvil como un mini PC
El uso de recursos digitales multimedia en los smartphones, requiere que las aplicaciones sean similares a
las de una PC. Con ello se logra compatibilizar el funcionamiento e intercambio de información entre
diferentes plataformas. Este debe ser tratado con todas las precauciones de seguridad y uso al momento de
navegar o descargar información proveniente de sitios sin seguridad.
El mercado mundial de teléfonos móviles vendidos a usuarios finales, en el cuarto trimestre del año 2012 es
el siguiente:17
Tabla 2-1 Empresas líderes en el mercado móvil
Empresa Mercado (4T 2012)
1.Samsung 19.6%
2.Nokia 23.4%
3.Apple 7.4
4.ZTE 4.0%
17 Gartner report: Worldwide Mobile Phone Sales Declined 1.7 Percent in 2012
45 | P á g i n a
5.Huawei Technologies 2.9%
6.TCL 2.2%
7.Lenovo 1.1%
8.Sony Mobile Communications 1.9%
9.Motorola 2.1%
10. Otros 31.8%
Los sistemas operativos móviles más usados a nivel global en el cuarto trimestre del 2012 son:18
Tabla 2-2 Sistemas operativos lideres para mercado móvil
Sistema Operativo Porcentaje de uso
Android 51.3
iOS 23.6
Research In Motion (BlackBerry) 8.8
Microsoft 1.8
Bada 2.1
Symbian 11.6
Otros 0.8
18 Gartner ídem
46 | P á g i n a
2.1.2 La importancia de la seguridad
Los usuarios de teléfonos móviles se han ido incrementando en los últimos años, debido a la extensa
variedad de aplicaciones que pueden instalar. Aproximadamente el 60.8% tienen un smartphone.19 La
navegación e intercambio de información en internet se ve beneficiada por la mejora de las redes
inalámbricas (Wi-Fi), facilitando el envío y recepción de correos electrónicos en cualquier momento, así
como la realización de diversas transacciones online.
Para garantizar el correcto funcionamiento del dispositivo, es esencial estar bien informado sobre las
ventajas y desventajas respecto de las prestaciones que ofrece el teléfono. También hay que considerar que
al mismo tiempo que nos mantiene comunicados, nos expone a peligros cuando éste es usado o intervenido
sin nuestro permiso. Las conversaciones vía telefónica o por mensajes de texto pueden contener
información confidencial y sensitiva, la cual podría ser escuchada o leída por otros a nivel global, cuando el
móvil se encuentra conectado al internet. Por ello es importante llevar a cabo algunas medidas de seguridad
para proteger el dispositivo y la información contenida en él.
2.2 Incidentes de seguridad
Se puede definir como amenaza a todo elemento o acción capaz de atentar contra la seguridad de la
información. Las amenazas surgen a partir de la existencia de vulnerabilidades, es decir que una amenaza
sólo puede existir si existe una vulnerabilidad que pueda ser aprovechada, e independientemente de que se
comprometa o no la seguridad de un sistema de información20
.
Diversas situaciones, tales como el incremento y el perfeccionamiento de las técnicas de ingeniería social, la
falta de capacitación y concientización a los usuarios en el uso de la tecnología, y sobre todo la creciente
rentabilidad de los ataques, han provocado en los últimos años el aumento de amenazas intencionales. Las
amenazas a los que se ven expuestos los teléfonos móviles son:
Pérdida o robo del dispositivo.
Infecciones por:
o Virus informáticos: Es un software malicioso que tiene por objeto alterar el normal
19 Estudio sobre seguridad en dispositivos móviles y smartphones (1er cuatrimestre 2012)
20 Departamento de informática- Universidad Nacional de Luján
47 | P á g i n a
funcionamiento de la computadora, sin el permiso o el conocimiento del usuario. Los
virus, habitualmente, reemplazan archivos ejecutables por otros infectados con el código
de este
o Malware vía email: Es un software que tiene como objetivo infiltrarse o dañar
una computadora o Sistema de información sin el consentimiento de su propietario.
o Botnets: Se refiere a un conjunto de robots informáticos o bots, que se ejecutan de manera
autónoma y automática. El artífice de la botnet puede controlar todos los
ordenadores/servidores infectados de forma remota.
o Hoaxes: Los hoax (mistificación, broma o engaño), son mensajes con falsas advertencias de
virus, o de cualquier otro tipo de alerta o de cadena (incluso solidaria, o que involucra a
nuestra propia salud), o de algún tipo de denuncia, distribuida por correo electrónico.
o Spam: Se llama spam, correo basura o mensaje basura a los mensajes no solicitados, no
deseados o de remitente no conocido (correo anónimo), habitualmente de tipo
publicitario, generalmente enviados en grandes cantidades (incluso masivas) que
perjudican de alguna o varias maneras al receptor.
o Rootkits: Un rootkit es un programa que permite un acceso de privilegio continuo a una
computadora pero que mantiene su presencia activamente oculta al control de los
administradores al corromper el funcionamiento normal del sistema operativo o de otras
aplicaciones.
o Falsos códigos QR: Un código QR (quick response code, «código de respuesta rápida») es
un módulo útil para almacenar información en una matriz de puntos o un código de barras
bidimensional. Se caracteriza por los tres cuadrados que se encuentran en las esquinas y
que permiten detectar la posición del código al lector.
Robo de información vía Bluetooth.
Suplantación de identidad (spoofing).
Acceso a datos confidenciales de conversaciones, imágenes o vídeos.
48 | P á g i n a
2.2.1 Tipos de Malware en los Smartphones
El tipo de malware que más se ha propagado en el año 2012, se puede clasificar de la siguiente forma:21
Tabla 2-3 Malware principal para telefonía móvil
Malware Características
1.TroyanosSMS El diseño del troyano como malware o virus informático, permite a su creador tener acceso remoto a un sistema. En este caso al sistema operativo de los smartphones infectados provocando daños, modificando los privilegios como usuario y poder acceder sin ninguna restricción, así como el robo de información valiosa para el usuario propietario del dispositivo móvil. Algunos troyanos detectados son: NetBus, Back Orifice, Back Orifice 2000, Sub7, The KaoS, Bifrost, Bandook, Poison Ivy, entre otros. Las acciones de un troyano son el apagado y reinicio del equipo para borrar, transferir o modificar archivos, robos de códigos de seguridad e instalación de otros programas maliciosos. Tales como los Botnets. Los riesgos se pueden presentar en dos posibles escenarios:
A. malware en aplicaciones y videojuegos: En este escenario, el usuario descarga aplicaciones y videojuegos de fuentes no oficiales. El malware se instala en el dispositivo mediante SMS ocultos para extraer información financiera y personal. Busca la lista de contactos y el dispositivo se convierte en parte de un botnet. Los botnets conocidos que representan un mayor peligro son Lethic, Grum, Cutwail (1,2,4,5), Donbot, Festi, Gheg, Kelihos y
Maazben.22
B. malware en SMS: El usuario recibe un SMS malware en su dispositivo proveniente de otro infectado y reenvía SMS a su lista de contactos, comenzando así de nuevo el ciclo.
2. Módulos publicitarios
Es uno de los medios por los cuales una amenaza puede dañar los equipos móviles. Se presentan como aplicaciones gratuitas de descarga que muestran publicidad y que cambian la página de inicio del dispositivo sin la autorización del usuario. Accede a la configuración del teléfono y extrae el número de identificación IMEI, así como la lista de permisos otorgados y acceso a las llamadas telefónicas. Los dos módulos que actúan de esta forma son Plangton y Hamob (AdWare.AndroidOS.Hamob). Los cuales sólo muestran anuncios
21 Kaspersky: Boletín de seguridad 2012. Estadística general de 2012
22 2013 - Global Security Report
49 | P á g i n a
publicitarios al usuario, mientras realizan acciones maliciosas en el dispositivo
móvil.23
3. Exploits
Buscan obtener los privilegios de superusuario o root. Es decir, el usuario root tiene los permisos para realizar acciones en el dispositivo que un usuario común no puede hacer. La principal amenaza de un exploit es la toma de control del dispositivo, así como el acceso privilegiado a los programas. Se puede presentar de tres formas: remoto, local y client side.
2.2.2 Malware en Sistemas Operativos Android
De acuerdo a los laboratorios Kaspersky, en su boletín de seguridad del año 2012. Las estadísticas mostraron
que el 98.96% del malware móvil detectado mensualmente fue en los SO Android. Seguidos en menor
porcentaje el Symbian con un 0.04% y otros con un 0.03%. La identificación de dicho malware es la
siguiente:24
Tabla 2-4 Malware atacante en sistema operativo Android
Malware en SO Android Porcentaje de propagación
Trojan-SMS. AndroidOS.Opfake.bo 32.87%
Trojan.AndroidOS.Plangton.a 18.27%
Trojan-SMS.AndroidOS.FakeInst.a 16.99%
Trojan-SMS.AndroidOS.Opfake.a 7.17%
AdWare.AndroidOS.Hamob.a 4.29%
Exploit.AndroidOS.Lotoor.g 1.69%
Trojan-Spy.AndroidOS.Fakeview 1.12%
Exploit.AndroidOS.Lotoor.c 0.66%
Trojan-SMS.AndroidOS.Agent.a 0.45%
23 Virus para móviles acechan Latinoamérica- http://itusersmagazine.com/tag/troyano-plangton/
24 Kaspersky: Boletín de seguridad 2012. Estadística general de 2012
50 | P á g i n a
Exploit.AndroidOS.Lotoor.p 0.38%
Otros 16.11%
2.3 Medidas de seguridad y prevención de riesgos
Algunas recomendaciones para incrementar la seguridad y evitar posibles riesgos son:
Tabla 2-5 Medidas de seguridad
Tipo de seguridad Medidas de seguridad y prevención
Física
Al reciclar un teléfono móvil, asegurarse de eliminar todo el contenido personal de las memorias. Así se evita exponer la confidencialidad del usuario y la de sus contactos.
Aplicaciones y Sistemas Operativos
Comprar e instalar aplicaciones y Software en páginas oficiales.
Instalar y mantener actualizado algún antivirus.
Usar deepfreeze Software, que permite el reinicio y restauración del sistema en plataformas Microsoft Windows, Mac OS X y Linux. Con el fin de evitar daños causados por programas maliciosos.
Apagar el móvil por la noche cuando no está siendo utilizado. Ya que los ataques a los sistemas pueden ocurrir cuando el usuario no está al tanto de ello.
Control de accesos y almacenamiento de datos
Usar contraseñas alfanuméricas o PIN para el acceso y tras la inactividad de los dispositivos.
Evitar proporcionar información financiera y personal vía correo electrónico, conversaciones telefónicas o por SMS.
Activar la encriptación de datos y cifrado de memorias SD.
51 | P á g i n a
Hacer copias de seguridad para restablecer el sistema en caso de fallos o pérdidas de información.
Usar servicios de localización online, para permitir el borrado de datos en caso de robo o extravío.
2.4 Telefonía móvil y su criptografía
En la telefonía móvil celular en GSM la criptografía se utiliza para la protección de escuchas no autorizadas.
El cifrado se realiza sobre pares de grupos de 57 bits con cifrado de interleaver, es decir, permutaciones. Son
similares para el proceso de autenticación y cifrado de datos de usuario, sin embargo tienen diferentes
algoritmos. Desde el centro de conmutación MSC la red GSM envía un número aleatorio RAND de 128 bits.
El móvil utiliza el número RAND para mezclarlos con un parámetro secreto K i disponible en el centro de
autenticación. El algoritmo llamado A8 procede a mezclar el número RAND de 128 con Ki generando la señal
Kc de 64 bits.
El algoritmo de criptografía A5 mezcla el número de trama de 22bits con Kc de 64 bits generando la señal S2
de 114bits. La señal S2 se utiliza para recuperar o componer los datos 2x57 bits luego son transmitidos por
puertas lógicas XOR.
Figura 2-1 Criptografía en redes GSM25
25 Abraham José Silva Orozco- Infografía de seguridad en dispositivos móviles 2013
52 | P á g i n a
2.5 Debilidades en la Seguridad
Hasta hace un tiempo, la mayoría de las comunicaciones en telefonía celular se lograban por medio de un
sistema global para las comunicaciones móviles (del inglés Global System for Mobile communications, GSM,
y originariamente del francés groupe spécial mobile) el cual es un sistema estándar, libre regalías, de
telefonía móvil digital.
Un cliente GSM puede conectarse a través de su teléfono con su computadora y enviar y recibir mensajes
por correo electrónico, faxes, navegar por Internet, acceder con seguridad a la red informática de una
compañía (red local/Intranet), así como utilizar otras funciones digitales de transmisión de datos, incluyendo
el servicio de mensajes cortos (SMS) o mensajes de texto.
GSM se considera, por su velocidad de transmisión y otras características, un estándar de segunda
generación (2G). Su extensión a 3G se denomina UMTS y difiere en su mayor velocidad de transmisión, el
uso de una arquitectura de red ligeramente distinta y sobre todo en el empleo de diferentes protocolos de
radio (W-CDMA).
En 2000, el grupo de trabajo para la estandarización del GSM se pasó al grupo TSG GERAN (Technical
Specification Group GSM EDGE Radio Access Network) del programa de cooperación 3GPP, creado para
desarrollar la tercera generación de telefonía móvil (3G). El sucesor del GSM, UMTS, fue introducido en
2001, sin embargo su aceptación fue lenta, por lo que gran parte de los usuarios de telefonía móvil en 2010
seguían utilizando GSM.26
Debido a éste cambio de estándar y a noticias acerca de ataques a las redes GSM, la seguridad del sistema
se ha visto seriamente comprometida. Para espiar la comunicación entre un móvil GSM y su operadora
basta con un Motorola de hace siete años27 y un programa que cualquiera se descarga de Internet. Según el
criptógrafo berlinés Karsten Nohl, estas herramientas no sólo permiten escuchar conversaciones y leer SMS
ajenos, sino incluso emular un teléfono y su tarjeta SIM. Más del 80% de los móviles en el mundo operan en
GSM.
La gente cree que está más expuesta a los cibercriminales en la PC que en el celular por “desconocimiento
de los problemas de las comunicaciones y móviles, y porque tampoco se han producido todavía ataques
espectaculares que hayan saltado a los medios, salvo quizás el robo de fotos en el terminal de Scarlett
26 GSM Association Latin America
27 Diario El país: LAIA REVENTÓS – “Su móvil es tan o más inseguro que su PC” sección sociedad 19 de diciembre del 2011
53 | P á g i n a
Johansson”28, sostienen David Pérez y José Picó expertos en seguridad, fundadores de la empresa española
Taddong y autores de Hacking y seguridad en comunicaciones móviles GSM/GPRS/UMTS/LTE.
¿Es el móvil tan inseguro o más que la PC? Depende del teléfono, de la PC y del sistema operativo. Y
también del usuario (unos buenos hábitos son la mejor defensa). A medida que los móviles son más
inteligentes los problemas de seguridad se asemejan a los de la PC.
El consultor de seguridad en Kaspersky Lab, Bosco Espinosa, considera al móvil más débil. De entrada, por
su tamaño: “Es más fácil perderlo o que lo roben con todos los datos, contraseñas incluidas, que lleva
dentro”. Otro dato: mientras el 90% de las PC tienen antivirus y cortafuegos, solo el 12% de los smartphones
llevan protección29.
Hasta hace unos años los ataques a móviles eran anecdóticos. Los aparatos eran simples y había una gran
diversificación e incompatibilidades entre el firmware y/o sistemas operativos de los distintos modelos. Es
decir, un código podía ejecutarse en un móvil pero no en otro aunque fuera de la misma marca. Sin
embargo, ya se ha identificado código malicioso para cualquier aparato móvil y sistema operativo. Hay
plataformas más seguras que otras, pero todos tienen vulnerabilidades, estas son puntos débiles del
software que permiten que un atacante comprometa la integridad, disponibilidad o confidencialidad del
mismo. Algunas de las vulnerabilidades más severas permiten que los atacantes ejecuten código arbitrario,
denominadas vulnerabilidades de seguridad, en un sistema comprometido30.
La aparición de sistemas operativos como Android (Google) o iOS (Apple) suponen una homogeneización del
software que ejecutan los teléfonos, de forma que un programa malicioso preparado para Android lo hará
de forma independiente al modelo o marca del móvil y tableta. Y esto posibilita que se puedan realizar
ataques a mayor escala (un mismo código infectaría a muchos móviles diferentes de forma indiscriminada).
Para un hacker o una persona malintencionada es más los smartphone que los viejos móviles porque
mientras uno contiene datos golosos y tiene más vías de comunicación por las que infiltrarse, sea la red
inalámbrica WIFI, bluetooth o el protocolo GSM; el otro básicamente almacenaba solamente contactos,
quitándole de esta manera, el valor que pudiera tener para un posible objeto de delito.
El móvil pues es tan o más vulnerable que la PC y se puede infectar a través de los protocolos GSM o
Bluetooth, los SMS y hasta mediante las tiendas de aplicaciones. Los riesgos, desde la “ingeniería social por
SMS hasta ataques de troyanos (por ejemplo, que creyendo que estamos instalando un juego, en realidad se
28 http://www.madrimasd.org/informacionidi/noticias/noticia.asp?id=51053
29 http://virusyantivirus.com/el-mercado-de-la-seguridad-movil-crecera-8-en-2013/
30 Diario El país: LAIA REVENTÓS Idem
54 | P á g i n a
introduce un código que espía nuestra información y la envía a terceros). Uno de estos troyanos es SpyEye:
Cuando se realiza una transferencia por Internet el banco envía una clave por SMS que se debe introducir en
la web para verificar que se es la persona. Estos troyanos, una vez instalados en el móvil, son capaces de
interceptar los SMS y permite al atacante realizar transferencias de dinero de forma ilegítima.
Como se menciono anteriormente, la tecnología GSM lleva desde 1998 “muerta” para los profesionales de
la seguridad, cuando se hicieron conocidas diversas técnicas para hacerse pasar por cualquiera que la use,
por debilidades en sus algoritmos criptográficos.
En el 2009 se descifraron los algoritmos que protegen las comunicaciones con GSM, sin embargo, un
reconocido criptólogo e investigador de seguridad alemán, Karsten Nohl dice que “las operadoras se
defienden con tres argumentos: dicen que es imposible, que si fuera posible sería muy complicado y que si
alguien pudiera no lo haría, porque es ilegal”31. Nohl sostiene que las operadoras de móviles no protegen
suficientemente del espionaje ni de las estafas a los clientes.
Para hacer frente a este problema, cientos de expertos en informática convocados por el congreso anual del
Chaos Computer Club asistieron en Agosto del 2012 a la presentación de sus investigaciones más recientes.
Valiéndose de un móvil y un software libre llamado Osmocom32, Se pudo emular el teléfono móvil de otra
persona sin tener que acceder al aparato en sí. La clave está en el intercambio de comunicación que un
móvil lleva a cabo con la operadora justo antes de establecer una llamada. Durante un segundo, el aparato
y la central telefónica intercambian una serie de mensajes codificados que casi siempre siguen el mismo
patrón. Cada serie tiene un significado concreto, como llamada entrante o fin de la comunicación.
Esto permite al espía o al delincuente predecir el contenido del mensaje y así, descifrarlo. Logrado esto en
cuestión de segundos, el atacante tendrá acceso a la conversación subsiguiente y a todas las que se realicen
con la misma codificación. Además le servirá para hacerse con el código de la tarjeta SIM y emular así el
teléfono atacado. Entonces podrá enviar mensajes de texto y hacer llamadas haciéndose pasar por el otro
teléfono. Las medidas de protección que deberían tomar las operadoras son sencillas y baratas. Sin embargo
aun son renuentes a tomarlos33 .
Las operadoras de móvil suelen referirse a la asociación GSMA como responsable de la seguridad en el
estándar GSM. Sin embargo, tiene dos grandes problemas en sus protocolos de comunicaciones, con lo que
no solo afectan a los teléfonos sino a todos aquellos aparatos que se conectan a esa red, sea un smartphone
31 Portaltic 22 de Julio del 2013, Revista Forbes, Parmy Olson “Sims cards have finally been hacked” - 7 de Julio 2013
32 http://osmocom.org/
33 (http://gsmmap.org)
55 | P á g i n a
o un portátil.
Por un lado, el algoritmo A5/1, que cifra las comunicaciones de voz, ya ha sido decodificado. Este fallo
permite además suplantar al usuario del teléfono para hacer y recibir llamadas.
Por el otro, cualquier atacante puede suplantar la estación base del operador de telecomunicaciones,
porque el protocolo GSM no define ningún mecanismo para que el móvil compruebe la autenticidad de la
red. Es decir, el teléfono no puede saber si la red a la que se está conectando es auténtica. En contraste a lo
anterior, la tecnología 3G es mucho más segura que GSM.
Mientras se convive entre GSM y 3G el usuario debería configurar el teléfono para que sólo se conecte con
la red 3G. Sin embargo, hay aparatos, como iPhone, que no lo permiten. Lo que es una ventaja para las
compañías telefónicas, porque es la terminal la que elige la red a la que se conecta en función de la
disponibilidad de cobertura, pero esto supone un mayor riesgo para la seguridad.
En el móvil, como en la PC, es difícil detectar si un cracker se ha infiltrado. Nunca se sabe, a ciencia cierta, si
equipo ha sido o está siendo atacado, y por eso se tiene muchos sistemas de protección en las PC. Lo
mismo, por tanto, debería hacerse con los teléfonos móviles. Bloquean y borran información, geolocalizan el
aparato (si tiene GPS) y algunos, hasta detectan, si se ha cambiado la SIM y qué nuevo número utiliza. Por
desgracia, se protegen de ciertas posibilidades, pero no cubren tanto como los de la PC.
56 | P á g i n a
57 | P á g i n a
CAPITULO III
Criterios y elección de un algoritmo criptográfico
para dispositivos móviles
3.1 Retos a superar con la elección
Actualmente con el desarrollo de nuevas tecnologías y del crecimiento en el poder computacional, es más
sencillo lograr quebrar la seguridad de los sistemas informáticos y de las comunicaciones pues es mucho
más sencillo acceder a las herramientas necesarias para ello. Un ejemplo claro de esto fue un reto que los
creadores del algoritmo RSA lanzaron: cifraron un texto con RSA y retaron al mundo a que lo descifrase.
Creían que no se podría hacer en menos de 40.000 billones de años. En 1993 se descifró; requirió del orden
de 100.000 billones de instrucciones del computador, la colaboración de cientos de voluntarios por toda la
Internet y el empleo de un método llamado Criba Múltiple Cuadrático-Polinómica. La realización de la
"hazaña" tomó aproximadamente ocho meses.
Tal como pasó en este caso, la historia ha comprobado, una y otra vez, que el tiempo necesario para
descifrar un mensaje es generalmente menor que el que se presupone según la teoría. Eso se debe a cuatro
factores fundamentales.
3.1.1 Creciente capacidad de cómputo de los computadores modernos.
A lo largo de los años se han descubierto procesos algorítmicos cada vez más eficaces para la resolución de
problemas matemáticos; lo que afecta muy especialmente a los algoritmos de clave asimétrica. Cualquier
sistema de cifrado de datos tiene puntos débiles, y los modernos (RSA, Diffie-Hellman, PGP, criptografía de
curva elíptica) no escapan a esta regla. Casi todos los códigos actuales requieren cadenas de dígitos elegidos
aleatoriamente, para lo que se utilizan generadores de números aleatorios o pseudoaleatorios. Pero si
dichos números no son realmente aleatorios, las claves así generadas son vulnerables.
En tal sentido, incluso un protocolo criptográfico bien implementado puede contener imperfecciones que
permitan un ataque más eficiente que el de "fuerza bruta". Más aún, puede afirmarse rotundamente que el
ingenio humano es incapaz de preparar una clave que el mismo ingenio humano no pueda resolver.
58 | P á g i n a
3.1.2 Recursos Computacionales.
El desarrollo de tecnologías avanzadas y menos costosas en el área de computación, incrementa en gran
medida la capacidad de cómputo de los actuales computadores. Esto facilita los ataques de "fuerza bruta" a
los algoritmos de encriptación. De esta forma, lo que en el pasado representaba cientos de años de cálculo,
en la actualidad puede verse reducido a pocos años, o quizás meses.
Adicionalmente, este desarrollo computacional apoya el procesamiento de algoritmos complejos capaces
de resolver problemas matemáticos de alta dificultad, como lo son la factorización de números primos muy
grandes y la resolución de logaritmos discretos. Sin embargo en el objetivo de esta tesis esta la delimitante
de que el móvil por ser un dispositivo basado en tareas no tan demandantes como lo que sería una
computadora de escritorio requiere el mismo nivel de seguridad en caso de algún ataque. En los capítulos
anteriores se ha puesto énfasis en lo peligroso que puede llegar a ser un aparato móvil en manos
desconocidas por tanto el uso correcto de los recursos computacionales a los que el móvil puede llegar es
de vital importancia para el éxito de la aplicación.
3.1.3 Incremento de dispositivos móviles.
Hoy en día se ha incrementado el uso de la web a través de los teléfonos celulares, los asistentes digitales
personales, y otros dispositivos de cómodo traslado. Diversas operaciones son llevadas a cabo a través de
estos dispositivos; enviar e-mail, comercio electrónico, etc. que requieren alto grado de seguridad.
Numerosos inconvenientes se presentan con estos dispositivos a la hora de adecuarlos a las tecnologías de
encriptación: Son pequeños, usan tecnología de comunicación de bajo ancho de banda, tienen poder de
procesamiento y memoria limitada, usan baterías de corta duración, etc. Sin embargo, el uso de los
dispositivos móviles se incrementa con gran rapidez y demanda el desarrollo de implementaciones
criptográficas que se adapten a ellos.
3.1.4 Velocidad en el proceso de encriptación y desencriptación.
El incremento en el uso de los dispositivos móviles ha hecho pensar en la velocidad de encriptación y
desencriptación de las actuales tecnologías criptográficas. Tal como se mencionó anteriormente, estos
dispositivos poseen una serie de limitaciones para el procesamiento de las técnicas de encriptación, entre
ellas está su velocidad. Más aún, estos dispositivos deben ser capaces de realizar actividades diferentes de
las referidas a la seguridad.
A continuación se presentan velocidades aproximadas del proceso de encriptación y desencriptación de
59 | P á g i n a
algunos de los criptosistemas actuales con un procesador de 1 GHz:
Tabla 3-1 Velocidad de los algoritmos de Encriptación.
Algoritmo Velocidad 1GHz Longitud de clave
DES 400 kb/s 56 bits
3DES 150 kb/s 112 bits
IDEA 200 kb/s 128 bits
Skipjack 400 kb/s 80 bits
CLIPPER chip No comparable 80 bits
En tal sentido, la demanda de velocidades mayores en el proceso de encriptación y desencriptación se
incrementa en la medida en que las técnicas criptográficas son aplicadas a dispositivos con menores
capacidades de cómputo. Por ello, se requieren nuevas tecnologías criptográficas que además de proveer
altos niveles de seguridad sean capaces de proporcionar grandes velocidades, acordes a las características
de los dispositivos móviles.
Por los cuatro puntos anteriores se puede delimitar que los retos afrontados en la presente tesis son los
siguientes:
El algoritmo encontrado y elegido no solamente debe ser difícil en su criptoanálisis, sino que debe
servirse de los recursos más bajos posibles
El rendimiento de la batería debe ser optimo
La implementación del algoritmo debe ser posible en el ámbito de los dispositivos móviles.
Delimitar mejoras para el algoritmo elegido, basándose en la premisa de que los algoritmos
actuales no fueron creados en una época donde el cómputo móvil existiera.
3.1.5 Comparativa energética entre los dispositivos móviles con mayor
cuota del mercado.
La siguiente comparativa en tablas están basadas en cifras oficiales, modificadas según el análisis para este
trabajo, el cual fue posible haciendo una investigación en medios de comunicación, entrevistas a usuarios
poseedores de algunos modelos y pruebas de carga de aplicaciones. En la autonomía en llamadas, se realiza
vía 3G, con la pantalla desconectada. En lo que respecta a la navegación web, con niveles de brillo medio. En
ambos casos, sin aplicaciones adicionales corriendo en segundo plano.
60 | P á g i n a
Tabla 3-2 Rendimiento de batería y especificaciones de móviles con mayor afluencia en el
mercado actual (año 2012-2013)34
Nexus 4 Nokia Lumia
920
LG Optimus G BlackBerry Z10
Pantalla 4.7
pulgadas, LCD IPS
4.5
pulgadas, LCD IPS
4.7
pulgadas, LCD IPS
4.2
pulgadas, LCD IPS
Procesador Qualcomm Snapdragon S4 Pro (APQ8064)
Qualcomm Snapdragon S4 (MSM8960)
Qualcomm Snapdragon S4 Pro (APQ8064)
Qualcomm Snapdragon (MSM8960T)
Sistema operativo
Android 4.2 (Jelly Bean)
Windows Phone 8 Android Jelly Bean 4.1.2 LG Optimus UI 3.0
BlackBerry 10
Dimensiones 68.7 × 133.9 × 9.1 mm 139 gramos
70.8 × 130.3 × 10.7 mm 185 gramos
68.9 × 131.9 × 8.45 mm 145 gramos
65.6 × 130 × 9 mm 137,5 gramos
Capacidad 2.100mAh 2.000mAh 2.100mAh 1800mAh
Carga inalámbrica
Sí Sí No No
La batería es Extraíble
No No No Sí
Autonomía De la bateria
Unas 14 horas en conversación, alrededor de 5 horas navegando
Le cuesta pasar de las 10 horas conversación 3G, unas 6 horas en navegación web
15 horas conversación , 5 horas navegación web
9 horas en conversación, 6 horas navegación
Comentario Mediocre, la autonomía es una debilidad en esté
Mediocre, en la línea de teléfonos Android de similar
En la media, muy
buena batería cuando se trata de
No dura demasiado en modo
34 Datos proporcionados en http://www.smart-gsm.com
61 | P á g i n a
modelo. Eso sí, Google ha hecho progresos importantes con respecto a Samsung Galaxy Nexus
tamaño y con especificaciones técnicas superiores (sobre el papel). Esperaba una
utilizarlo para realizar llamadas, cuando tiramos de potencia (navegar, vídeo, juegos), nos la comemos en poco tiempo. El teléfono presenta
un modoECO, que
juega con los núcleos para mejorar el rendimiento
conversación, pero su pequeña batería se comporta bien en el resto de circunstancias. Su pantalla más pequeña también le pide menos energía.
HTC One Sony Xperia Z iPhone 5 Samsung Galaxy
S4
Pantalla 4.7 pulgadas, LCD IPS
Full HD
5
pulgadas, LCD IPS
Full HD
4
pulgadas, LCD IPS
5
pulgadas, AMOLED
Full HD
Procesador Qualcomm Snapdragon 600
Qualcomm Snapdragon S4 Pro (APQ8064)
Apple A6 (APL0589)
Qualcomm Snapdragon 600
Sistema operativo
Android Jelly Bean 4.1.2
Personalización HTCSe
nse 5.0
Android Jelly Bean 4.1.2 Personalización Sony
iOS 6.1.3 Android 4.2.2 Jelly Bean Personalización TouchWiz
Dimensiones 68.2 × 137.4 × 9.3 mm 143 gramos
71 × 139 × 7.9 mm 146 gramos
58.6 × 123.8 × 7.6 mm
69.8 × 136.6 × 7.9 mm 130 gramos
Capacidad 2.300mAh 2.330mAh 1.440mAh 2.600mAh
Carga inalámbrica
No No No Sí
La batería es Extraíble
No No No Sí
Autonomía de la batería
Más de 14 horas en conversación, más de 9 horas en navegación web
16 horas en conversación, alrededor de 7 horas en navegación web
9 horas en conversación, alrededor de 10 horas en navegación web
14 horas en conversación, alrededor de 9 horas en navegación web
Comentario Una buena batería, Muy capaz incluso con tareas
5 pulgadas con la máxima resolución y
Pantalla más pequeña, el más
En un tamaño parecido al S3, se
62 | P á g i n a
complicadas, especialmente con la navegación web
un hardware muy potente que tiene una autonomía notable. Se tiene un modo
Stamina que
alarga de forma considerable en tiempo de espera
delgado del grupo y con una batería menor, pero con un funcionamiento notable.
tienen 500mAh
más. La autonomía
en todas las situaciones es muy buena y se puede tener de referencia, al poder reemplazar la batería
Samsung Galaxy Note II Motorola RAZR MAXX
Pantalla 5,5 pulgadas, AMOLED 4,3 pulgadas, AMOLED
Procesador Samsung Exynos 4412 Quad
TI OMAP 4430
Sistema operativo Android 4.1.1 Jelly Bean Personalización TouchWiz
Android 4.0 Ice Cream Sandwich
Dimensiones 151.1 × 80.5 × 9.4 mm 183 gramos
130.7 × 68.9 × 9 mm 140 gramos
Capacidad 3.100 mAh 3.300 mAh
Carga inalámbrica No No
La batería es Extraíble Sí No
Autonomía de la batería
17 horas en conversación, alrededor de las 10 horas en navegación web
Más de 20 horas en conversación, alrededor de las 10 horas en navegación web
Comentario La segunda batería más grande de la comparativa, equipada Samsung con el hardware Exynos y la pantalla AMOLED consiguen en la práctica una autonomía más que notable. .
Los teléfonos más capaces en el mercado son de Motorola, con sus versiones MAXX. Tenemos una batería de 3.300mAh, y una autonomía imbatible (ayuda la pantalla de 4.3 pulgadas) y no es pesado
Una vez repasadas las principales características se procederá a elegir el algoritmo que se desarrolle mejor
con las cifras de autonomía antes mencionadas.
63 | P á g i n a
3.2 Fundamentación de la elección
3.2.1 Criterios de elección del algoritmo base AES
En cualquier sistema o dispositivo, la seguridad del cifrado depende de diversos factores que van
directamente relacionados con la capacidad del dispositivo que los aloja. Los algoritmos de cifrado definen
transformaciones de datos que los usuarios no autorizados no pueden revertir con facilidad. Ningún
algoritmo único resulta idóneo para todas las situaciones. No obstante, en esta tesis se seleccionaron los
siguientes principios generales basándose en la capacidad de cómputo de los móviles actuales:
El cifrado seguro suele consumir más recursos que un cifrado menos seguro.
El cifrado asimétrico es más seguro que el simétrico basándonos en que la distribución de claves es
más fácil y segura ya que la clave que se distribuye es la pública manteniéndose la privada para el
uso exclusivo del propietario, pero este sistema tiene bastantes desventajas:
o Para una misma longitud de clave y mensaje se necesita mayor tiempo de proceso.
o Las claves deben ser de mayor tamaño que las simétricas.
o El mensaje cifrado ocupa más espacio que el original.
Las contraseñas largas y complejas son más seguras que las contraseñas cortas, sin embargo tienen
la desventaja de que al ser más largas aumenta la posibilidad de que el usuario olvide la misma o la
pierda.
La seguridad de los algoritmos actuales en pruebas anteriores hechas por los organismos de
seguridad internacionales como por ejemplo NIST o el gobierno de los Estados Unidos.
Con base en lo anterior, preliminarmente se eligió el algoritmo AES (Advanced Encryption Standard),
también conocido como Rjindael, para comenzar las pruebas en móviles ya que es uno de los algoritmos de
cifrado por bloques más sofisticados y seguros del momento.
De hecho, este popular estándar se usa en operaciones tan importantes como pagos electrónicos o
transacciones bancarias.
3.2.2 Algoritmo simétrico
Pese a que simple vista los algoritmos asimétricos pudieran proveer una implementación y velocidad de
cálculo mejor que los algoritmos simétricos, la realidad es otra: El cifrado simétrico es más rápido que el
cifrado asimétrico, debido a la simplicidad de los algoritmos de clave privada necesarios para un
64 | P á g i n a
determinado nivel de seguridad. Los algoritmos de cifrado asimétricos son más complejos lo que se
contrapone a uno de nuestros objetivos pues es necesario que se pueda implementar en un dispositivo
móvil y no consuma demasiados recursos al ser estos limitados en el mismo. El cifrado asimétrico
normalmente lleva 100 veces más tiempo para cifrar un mensaje dado que el simétrico.
Por lo anterior, la categoría de algoritmos simétricos es la más apta para comenzar a probar y mejorar la
seguridad en los mismos.
3.2.3 Análisis y comparativa de algoritmos simétricos
Una vez elegida la categoría de algoritmos simétricos, se procedió a analizar los algoritmos existentes dentro
de la misma para corroborar que la primera elección (El algoritmo AES) fuera la más acertada para
implementar en un dispositivo móvil. Mediante las pruebas desarrolladas se buscó determinar si el
algoritmo AES es el más usado debido a su velocidad y seguridad, o si es el más utilizado sólo por su fama o
conveniencia comercial y por tanto, qué tan efectivo es en sistemas cuyo poder de cómputo no es del todo
potente como es el caso de los teléfonos móviles. La metodología del análisis está basada en un trabajo
titulado “Comparación de Perfomance Hardware entre Algoritmo de Cifrado estándar AES y otros
actuales”35
3.2.3.1 Elección de Herramientas
Para la elección de las herramientas era necesario que el software utilizado tuviera la opción de comparar el
algoritmo AES directamente. Por lo tanto, una de las primeras restricciones a tener en cuenta para
seleccionar el software fue que tuviera entre sus opciones a dicho algoritmo. Lo siguiente necesario fue que
las herramientas fueran de código abierto o gratuito para que el análisis no significara una inversión
monetaria fuerte.
Por consiguiente, se eligieron cuatro aplicaciones que cumplían con estos requisitos:
CYASSL36
: Consiste en una biblioteca basada en el lenguaje de programación C que puede ser
utilizada en ambientes embebidos por su pequeño tamaño y velocidad, siendo 20 veces menor que
OpenSSL. Asimismo, incluye algoritmos de cifrado más novedosos. La lista de algoritmos de
encriptación que incluye es la siguiente: AES, ARC4, RABBIT y 3DES. Las pruebas se llevarán a cabo
35White paper Benchmarking de Algoritmos Simétricos, Lazzati Laura, Majian Carolina, Masi Alejandro, Pablos Federico, Rocha Ivan
36 http://freecode.com/projects/cyassl
65 | P á g i n a
en un entorno Linux Ubuntu debido a su facilidad de ser utilizado por línea de comandos.
OpenSSL37
: Es una implementación OpenSource de los protocolos SSL y TLS, y se halla escrita en el
lenguaje de programación C. Tiene versiones disponibles para los sistemas operativos Linux y
Microsoft Windows, y los algoritmos criptográficos que implementa son: AES, Blowfish, Camellia,
SEED, CAST-128, DES, IDEA, RC2, RC4, RC5, TDES, GOST 28147-89, RSA y DSA. Las pruebas también
se llevarán a cabo en un entorno Linux Ubuntu.
TrueCrypt38
: Aplicación gratuita cuyo código fuente está disponible, permite crear volúmenes
cifrados, de tal forma que todo lo que contengan pueda ser accedido sólo por una contraseña o
archivo clave de creación. Este permite hacer comparaciones entre los distintos algoritmos sobre
velocidad de encriptación, de desencriptación, y velocidad media utilizando distintos tamaños de
buffers. Los algoritmos de encriptación con los que trabaja son: Twofish, AES y Serpent. Si bien está
disponible para los sistemas operativos Linux y Windows, sólo se realizaron pruebas con el sistema
operativo Windows ya que su instalación en un sistema Linux es bastante más compleja.
CrypTool39
: Es una aplicación gratuita que incluye análisis de fuerza bruta para diferentes
algoritmos, criptoanálisis y una explicación detallada de la criptografía clásica simétrica. Está
disponible para sistemas operativos Windows y entre sus algoritmos se encuentran Vigenére,
Cesar, RSA, AES y Enigma. Este último programa se utilizo para analizar los procesos de cada
algoritmo y su velocidad.
En el siguiente apartado se explicarán las pruebas realizadas. Los resultados obtenidos son expresados en
tablas comparativas con su respectivo gráfico.
3.2.3.2 Pruebas realizadas sobre los algoritmos
Las pruebas consistieron en utilizar un archivo de 100kb con texto plano dentro y aplicarle cada algoritmo
de encriptación con los que las herramientas contaban con el fin de saber la velocidad a la que se desarrolla
la encriptación. Cada uno de los resultados (medidos en mbits por segundo) fueron colocados en tablas
comparativas para su posterior análisis.
Para ello cada herramienta (dependiendo si corría en distribuciones Linux o Windows) se instalo en 5
37 http://www.openssl.org
38 http://www.truecrypt.org
39 https://www.cryptool.org/en/
66 | P á g i n a
computadoras diferentes con las siguientes características:
- Procesador 1.3 GHz ARM: La elección de este procesador es debido a que actualmente los teléfonos
móviles utilizan tecnología ARM para funcionar. Este procesador es uno de los más parecidos a los
de un smartphone actual según las características dadas en la página del fabricante40
.
- Memoria RAM: La computadora numerada como 1, 3 y 5 utilizaron una memoria de 512 MB,
mientras que las restantes contaron con una memoria de 1 GB.
Después de aplicar el algoritmo al archivo en cuestión y medir su velocidad en cada uno de los 5 equipos de
cómputo se lograron varias tablas, obteniendo los siguientes resultados con cada una de las herramientas
antes descritas:
Tabla 3-3 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta
truecrypt
Prueba 1 Prueba 2 Prueba 3 Prueba 4 Prueba 5
AES 215 62,3 216 86,4 112
Twofish 157 48,1 155 82,9 99
Serpent 104 29,7 105 49,8 52,2
Figura 3-1: Promedio en Mbits/s para distintas computadoras con true crypt
40 http://www.arm.com/products/processors/index.php
67 | P á g i n a
Tabla 3-4 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta
CyaSSL
Prueba 1 Prueba 2 Prueba 3 Prueba 4 Prueba 5
3DES 17,86 12,64 11,59 7,61 11,14
AES 82,17 77,75 70 47,28 56,93
ARC4 90,09 66,47 81,76 78,01 124,97
RABBIT 300,57 223,36 144,99 171,69 143,24
Figura 3-2 Tiempo de ejecución en cada prueba por algoritmo en la herramienta CyaSSL
Tabla 3-5 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta
Cryptool
Prueba 1 Prueba 2 Prueba 3 Prueba 4 Prueba 5
rc4 168,04 220,76 240,56 149,46 180,28
des cbc 23,13 31,93 56,17 18,58 28,32
des ede3 7,95 11,89 20,86 6,92 10,26
rc2 cbc 23,84 31,08 29,87 15,76 13,91
blowfish cbc
87,16 93,48 93,25 49,67 45,86
aes-128 cbc 76,32 102,98 44,01 56,13 49,56
aes-192 cbc 57,64 87,8 32,93 49,93 46,8
aes-256 cbc 31,34 78,68 33 44,19 42,41
aes-128 ige 75,78 97,25 39,17 55,46 76,18
aes-192 ige 65,17 85,45 29,3 48,82 66,95
aes-256 ige 23,77 71,63 30,31 43,26 59
68 | P á g i n a
Figura 3-3 Tiempo de ejecución mbits/seg en cada prueba por algoritmo en la herramienta Cryptool
Luego de analizar los resultados obtenidos en los diferentes equipos hardware, se llegó a la conclusión de
que existen dos algoritmos con una velocidad notablemente mayor al algoritmo del AES, que son RC4 y
Rabbit. Este fue un resultado no del todo esperado debido a que el Algoritmo AES es el más utilizado
actualmente, sin embargo se decidió analizar las características de estos dos algoritmos para verificar que
cumplieran con las especificaciones para ser implementados en dispositivos móviles.
Primeramente, en cuanto a su funcionamiento se destaca que tanto RC4 como Rabbit son algoritmos para
cifrado de flujo, mientras que AES es de bloque. Es sabido que los algoritmos de flujo son, por su modo de
funcionamiento, más rápidos que los de bloque, además de tener una menor complejidad a nivel de
hardware. Sin embargo, los algoritmos de cifrado de bloque suelen requerir de más memoria para
funcionar, puesto que trabajan con bloques de datos mayores que los de flujo y son más susceptibles a la
existencia de ruidos en la transmisión, lo que implica que si se interrumpe la transmisión de datos es
imposible recuperarlos, mientras que los de flujo sí se pueden hacerlo ya que los datos son encriptados
individualmente byte a byte.41
Ante esto, se procedió a analizar si era posible utilizar entonces algoritmos de cifrado de flujo en un entorno
móvil en vez de la primera elección (AES) tomando en cuenta las características que estos poseen. Al
41 Jorge Ramió (UPM) - Criptografía y Seguridad Informática
69 | P á g i n a
finalizar se encontraron algunas desventajas42
:
- Son más difíciles de implementar correctamente y están más predispuestos a debilidades basadas
en su uso, dado que tienen requerimientos muy estrictos.
- No proveen protección de integridad o autenticación, mientras que algunos de los algoritmos de
cifrado de bloque sí lo hacen, y suelen tener mayor seguridad.
- Requieren de mayor memoria para funcionar.
- Si se llega a interrumpir la transmisión es casi imposible recuperar la totalidad de los datos.
Entrando más en detalle a los algoritmos en cuestión, el algoritmo RC4 o ARC era un secreto comercial
hasta que alguien publicó código fuente de un algoritmo, declarando que era equivalente a RC4. El
algoritmo es muy rápido, por lo cual puede tener uso en ciertas aplicaciones. Si bien tiene un mayor
velocidad sobre el hardware que el AES, fue excluido de cualquier estándar de alta seguridad y algunos
modos de usar el algoritmo de criptografía RC4 lo han llevado a ser un sistema de criptografía muy inseguro.
Con respecto al Rabbit, es un algoritmo de cifrado de flujo reciente, basado en iterar un conjunto de
funciones no lineales acopladas. Se caracteriza por su alta rendimiento en software, y no se han encontrado
hasta el momento debilidades criptográficas significativas. Sin embargo al ser un algoritmo relativamente
nuevo su implementación es demasiado compleja lo que implicaría costos altos.
Dado que una de las premisas para el presente trabajo era que la implementación del algoritmo fuera
realizable en un entorno móvil, ambos algoritmos tienen la desventaja de que su implementación es
compleja, lo que llevaría más tiempo de desarrollo y de que ambos necesitan más memoria para funcionar ,
un recurso limitado e indispensable que es necesario racionar, por esto se encontró que el AES sigue siendo
el algoritmo de cifrado de bloque más rápido a nivel hardware entre los algoritmos de cifrado que se
analizaron.
Las siguientes tablas denotan, en reasumidas cuentas, los resultados obtenidos entre las tres herramientas y
el promedio de velocidad alcanzado total en cada una de las computadoras.
42 Jorge Ramió (UPM) - Criptografía y Seguridad Informática
70 | P á g i n a
Tabla 3-6 Resultados Finales: Uniendo las tres herramientas. Unidad/MB-S
Truecrypt Cryptool CyaSSL
3DES 0 11,22 0
AES 135,96 59,08 61,67
ARC4 0 82,8 203,78
blowfish cbc
0 0 61,67
Camellia 0 0 59,35
cast cbc 0 0 43,12
Des 0 0 20,57
RABBIT 0 184,62 0
rc2 cbc 0 0 24,01
seed cbc 0 0 32,92
Serpent 67,48 0 0
Twofish 107,06 0 0
Whirlpool 0 0 15,87
Figura 3-4 Comparativa en función del software (en Mbits/s)
71 | P á g i n a
Tabla 3-7 Velocidad promedio en Mbits/s de todos los algoritmos analizados en los
correspondientes 5 equipos
MB/s velocidad
3DES 11,22
whirlpool 15,87
DES 20,57
rc2 cbc 24,01
seed cbc 32,92
cast cbc 43,12
camellia 59,35
blowfish cbc
61,67
Serpent 67,48
Twofish 107,06
AES 135,96
RABBIT 184,62
ARC4 203,78
Figura 3-5 Rendimiento promedio en Mbits/s de todos los algoritmos analizados en los correspondientes
5 equipos
72 | P á g i n a
3.2.4 Algoritmo elegido AES: Conceptos básicos
Advanced Encryption Standard (AES), también conocido como Rijndael (Nombre derivado de los apellidos de
sus dos creadores), es un esquema de cifrado por bloques adoptado como un estándar de cifrado por el
gobierno de los Estados Unidos. El AES fue anunciado por el Instituto Nacional de Estándares y Tecnología
(NIST) como FIPS 43
PUB 197 de los Estados Unidos (FIPS 197) el 26 de noviembre de 2001 después de un
proceso de estandarización que duró 5 años. Se transformó en un estándar efectivo el 26 de mayo de 2002.
Desde 2006, el AES es uno de los algoritmos más populares usados en criptografía simétrica.
El cifrado fue desarrollado por dos criptólogos belgas, Joan Daemen y Vincent Rijmen, ambos estudiantes de
la Katholieke Universiteit Leuven, y enviado al proceso de selección AES bajo el nombre "Rijndael".
Figura 3-6 Proceso de encriptación del algoritmo AES44
43 Federal Information Processing Standard
44 AES inspector
73 | P á g i n a
Historia
En 1997, el Instituto Nacional de Normas y Tecnología (NIST) decidió realizar un concurso para escoger un
nuevo algoritmo de cifrado capaz de proteger información sensible durante el siglo XXI.
El 2 de enero de 1997 el NIST anunció su intención de desarrollar AES, con la ayuda de la industria y de la
comunidad criptográfica. El 12 de septiembre de ese año se hizo la convocatoria formal. En esta
convocatoria se indicaban varias condiciones para los algoritmos que se presentaran:
Ser de dominio público, disponible para todo el mundo.
Ser un algoritmo de cifrado simétrico y soportar bloques de, como mínimo, 128 bits.
Las claves de cifrado podrían ser de 128, 192 y 256 bits.
Ser implementable tanto en hardware como en software.
El 20 de agosto de 1998 el NIST anunció los 15 algoritmos admitidos en la primera conferencia AES. La
segunda conferencia AES tuvo lugar en marzo de 1999 donde se discutieron los análisis a los que fueron
sometidos los candidatos por la comunidad criptográfica internacional. Se admitieron comentarios hasta el
15 de abril. El NIST decidió en agosto de 1999 cuales serían los 5 finalistas:
MARS
RC6
RIJNDAEL
SERPENT
TWOFISH
Estos algoritmos fueron sometidos a una segunda revisión, más exhaustiva, que duró hasta el 15 de mayo
de 2000. Durante este periodo el NIST admitió análisis de los algoritmos finalistas.
Durante los días 13 y 14 de abril de 2000 tuvo lugar la tercera conferencia AES donde se discutieron los
últimos análisis de los algoritmos finalistas. En ella estuvieron presentes los desarrolladores de los
algoritmos finalistas.
El 15 de mayo de 2000 finalizó el periodo público de análisis. El NIST estudió toda la información disponible
para decidir cuál sería el algoritmo ganador. El 2 de octubre de 2000 se votó cual sería el algoritmo que
finalmente ganaría el concurso. El resultado fue el siguiente:
74 | P á g i n a
MARS: 13 votos
RC6: 23 votos
RIJNDAEL: 86 votos
SERPENT: 59 votos
TWOFISH: 31 votos
El algoritmo Rijndael ganó el concurso y en noviembre de 2001 se publicó FIPS 197 donde se asumía
oficialmente.
3.2.5 Desarrollo
Rijndael fue un refinamiento de un diseño anterior de Daemen y Rijmen: Square. Al contrario que su
predecesor DES, Rijndael es una red de sustitución-permutación, no una red de Feistel45
. AES es rápido tanto
en software como en hardware, es relativamente fácil de implementar, y requiere poca memoria.
3.2.6 Seguridad de AES
En el año 2011 los investigadores de Microsoft Research 46
descubrieron una vulnerabilidad en el algoritmo
AES. Describieron que incluso conociendola no tiene implicaciones prácticas en la seguridad de los datos
pues se necesitaría un billón de ordenadores que pudieran cada uno probar mil millones de claves por
segundo, tardarían más de 2.000 millones de años en dar con una del sistema AES-128, y hay que tener en
cuenta que las máquinas actuales sólo pueden probar 10 millones de claves por segundo. Antes de ello no
se había encontrado ningún ataque exitoso contra el AES.
La Agencia de Seguridad Nacional de los Estados Unidos (NSA) revisó todos los finalistas candidatos al AES,
incluyendo el Rijndael, y declaró que todos ellos eran suficientemente seguros para su empleo en
información no clasificada del gobierno de los Estados Unidos. En junio de 2007, el gobierno de los Estados
Unidos anunció que el AES podía ser usado para información clasificada:
45 Cifrado de Feistel es un método de cifrado en bloque con una estructura particular. También es conocida comúnmente como Red de
Feistel. Un gran número de algoritmos de cifrado por bloques lo utilizan, siendo el más conocido el algoritmo Data Encryption Standard
(DES).
46 http://research.microsoft.com/en-us/
75 | P á g i n a
"The design and strength of all key lengths of the AES algorithm (i.e., 128, 192 and 256) are sufficient to
protect classified information up to the SECRET level. TOP SECRET information will require use of either the
192 or 256 key lengths. The implementation of AES in products intended to protect national security systems
and/or information must be reviewed and certified by NSA prior to their acquisition and use. "47
Este hecho marca la primera vez que el público ha tenido acceso a un cifrador aprobado por la NSA para
información secreta (TOP SECRET).
El método más común de ataque hacia un cifrador por bloques consiste en intentar varios ataques sobre
versiones del cifrador con un número menor de rondas. El AES tiene 10 rondas para llaves de 128 bits, 12
rondas para llaves de 192 bits, y 14 rondas para llaves de 256 bits. Hasta 2005, los mejores ataques
conocidos son sobre versiones reducidas a 7 rondas para llaves de 128 bits, 8 rondas para llaves de 192 bits,
y 9 rondas para llaves de 256 bits (Ferguson et al, 2000).
Algunos criptógrafos muestran preocupación sobre la seguridad del AES. Consideran que el margen entre el
número de rondas especificado en el cifrador y los mejores ataques conocidos es muy pequeño. El riesgo es
que se puede encontrar alguna manera de mejorar los ataques y de ser así, el cifrado podría ser roto. En el
contexto criptográfico se considera "roto" un algoritmo si existe algún ataque más rápido que una búsqueda
exhaustiva (ataque por fuerza bruta). Hasta el momento, tales preocupaciones pueden ser ignoradas. El
ataque de fuerza bruta más largamente publicitado y conocido ha sido contra una clave de 64 bits RC5 por
distributed.net.
Otra preocupación es la estructura matemática de AES. A diferencia de la mayoría de cifradores de bloques,
AES tiene una descripción matemática muy ordenada. Esto no ha llevado todavía a ningún ataque, pero
algunos investigadores están preocupados que futuros ataques quizá encuentren una manera de explotar
esta estructura.
En 2002, un ataque teórico, denominado "ataque XSL", fue anunciado por Nicolas Courtois y Josef Pieprzyk,
mostrando una potencial debilidad en el algoritmo AES. Varios expertos criptográficos han encontrado
problemas en las matemáticas que hay por debajo del ataque propuesto, sugiriendo que los autores quizá
hayan cometido un error en sus estimaciones. Si esta línea de ataque puede ser tomada contra AES, es una
cuestión todavía abierta. Hasta el momento, el ataque XSL contra AES parece especulativo; es improbable
que nadie pudiera llevar a cabo en la práctica este ataque.
47 CNSS Policy No. 15, Fact Sheet No. 1 National Policy on the Use of the Advanced Encryption Standard (AES) to Protect National
Security Systems and National Security Information June 2003
76 | P á g i n a
3.2.7 Funcionamiento básico del algoritmo elegido: AES
Estrictamente hablando, AES no es precisamente Rijndael (aunque en la práctica se los llama de manera
indistinta) ya que Rijndael permite un mayor rango de tamaño de bloques y longitud de claves; AES tiene un
tamaño de bloque fijo de 128 bits y tamaños de llave de 128, 192 o 256 bits, mientras que Rijndael puede
ser especificado por una clave que sea múltiplo de 32 bits, con un mínimo de 128 bits y un máximo de 256
bits.
La mayoría de los cálculos del algoritmo AES se hacen en un campo finito determinado.
AES opera en una matriz de 4×4 bytes, llamada state (algunas versiones de Rijndael con un tamaño de
bloque mayor tienen columnas adicionales en el state).
AES utiliza claves de 128, 192 o 256 bits de longitud, sobre bloques fijos de 16 bytes, lo que da como
resultado bloques cifrados en la salida del mismo tamaño que en la entrada, 16 bytes.
Uno de los puntos destacados del AES es la manera en la que se aplica su clave K . En primer lugar, ésta se
expande en un subconjunto formado por (k0,k1,k2,… kn), a cada una de ellas se le aplica una función round
r(kn, ), que realiza una operación binaria XOR con el mensaje, es decir, el bloque de entrada es cifrado por
cada una de las subclaves r( kn )hasta llegar al final.
En cada round, se llevan a cabo diferentes funciones de sustitución y permutación, por lo tanto se cambia
el orden y estado inicial de los datos incluidos en el mensaje inicial. Este proceso debe ser reversible, para
que el sistema sea capaz de desencriptar el mensaje.
77 | P á g i n a
Figura 3-7 Diagrama general del algoritmo AES y su funcionamiento48
48 Apuntes de criptografía de la Facultad de Ingeniería de la UNAM, Mayo 2013
78 | P á g i n a
Pseudocódigo
Expansión de la clave usando el esquema de claves de Rijndael.
Etapa inicial:
AddRoundKey – Calculo de las sub claves, cada byte del «state» se combina con un byte de la subclave
usando la operación XOR (⊕).
Figura 3-8 Función Addround
Rondas:
SubBytes —Aquí cada byte del actual estado es sustituido por su correspondiente, según una tabla S de
búsqueda.
Figura 3-9 Función Bytesub
ShiftRows — en este paso se realiza una transposición donde cada fila del «state» es rotada de manera
cíclica un número determinado de veces.
Figura 3-10 Función Shiftrows
MixColumns — operación de mezclado que opera en las columnas del «state», combinando los cuatro bytes
79 | P á g i n a
en cada columna usando una transformación lineal.
Figura 3-11 Función MixColumns
Salida
Finalmente, después de aplicar 10 rounds sobre los 16 bytes del bloque de entrada, se obtiene en la salida
un bloque de igual tamaño, 16 bytes. De hecho, tanto el mensaje como las round keys mantienen una
longitud de 128 bits durante todo el proceso.
Descifrado
Figura 3-12 Proceso de descifrado del Algoritmo AES 49
49 Informe de Seguridad europea para USA- Alfonso Muñoz Muñoz 2004
80 | P á g i n a
81 | P á g i n a
CAPITULO IV
Propuesta de mejoras al algoritmo
Tomando en cuenta las limitaciones que poseen los dispositivos móviles en la actualidad (poder de
procesador, duración de la batería y memoria interna) se proponen algunas mejoras para el rendimiento del
algoritmo AES, manteniendo su seguridad para lograr un balance entre ambas al fin de ser utilizado en
cualquier dispositivo móvil sin sacrificar la vida de la batería que es lo primordial.
Se requiere una optimización tomando en cuenta también que los actuales teléfonos móviles utilizan
microprocesadores ARM de 32 bits, con lo cual se procederá a simularlos con el programa Keil uVision4 que
es proporcionado en la misma página de los procesadores ARM como un kit de herramientas para
desarrolladores.
En este capítulo se describe la implementación del algoritmo AES así como las mejoras de rendimiento que
se proponen aplicar al mismo.
El capítulo se divide en dos apartados, en los que se explican los principales bloques de la presente tesis:
Implementación.
Mejoras de rendimiento, tomando como base el tiempo de ejecución.
Cada uno de ellos llevara un diseño de algoritmo que variará con las mejoras del mismo bloque. Para
comprobar su funcionamiento se usaron los conjuntos de vectores facilitados por el NIST (National Institute
of Standards and Technology ) en la sección de los algoritmos de cifrado de bloque.50
Se probó en sus posibles tamaños de clave (128, 192 y 256 bits) para cifrar y descifrar y posteriormente se
irán aplicando las mejoras para procesadores de 32 bits que son el estándar de la mayoría de los teléfonos
móviles actuales (a excepción de la nueva gama de iphone o del Samsung galaxy S4 que usan una
arquitectura de 64 bits).
Esto se ha hecho en lenguaje de programación C para su implementación en el microprocesador ARM7
mediante el programa Keil uVision4 y poder utilizarlo en las mediciones de la velocidad y rendimiento.
50 Dworkin, Morris. Recommendation for Block Cipher Modes of Operation, Methods and Techniques NIST
82 | P á g i n a
4.1 Entorno de trabajo
4.1.1 Microprocesador para móviles
Cuando se pensó en la arquitectura del procesador se tenía claro, por los anteriores análisis, que sería ARM
debido a que los procesadores ARM son predominantes en el mercado, llegando a utilizarse en millones de
teléfonos, tabletas o sistemas de videojuegos portátiles entre otras aplicaciones. En todas mantienen la
premisa de un procesamiento relativamente elevado y un consumo de energía bajo lo cual viene bien para
las especificaciones de energía de ahorro de batería en el presente trabajo.
Se denomina ARM (Advanced RISC Machines) a una familia de microprocesadores diseñados por la empresa
Acorn Computers y desarrollados por Advanced RISC Machines Ltd. Los microprocesadores ARM7 son unos
microprocesadores con arquitectura de 32 bits, son de bajo coste y están orientados a sistemas móviles
que ofrecen una muy buena capacidad de cómputo. En concreto el chip utilizado está presente en
dispositivos tales como Game Boy Advance, Nintendo DS, Apple iPod, Samsung Galaxy , Lego NXT, y Juice
Box entre otros.
A pesar de que el sector de los microprocesadores se renueva a una gran velocidad, el mercado sigue
utilizando microprocesadores sucesores del ARM7, lo cual permite que los resultados de esta tesis puedan
ser migrados a cualquier tipo de teléfono celular que tenga alguna gama de este procesador.
4.1.2 Kit de desarrollador ARM- Keil uVision4
La implementación del algoritmo AES ha sido desarrollado mediante el programa uVision4 del fabricante
Keil.
Figura 4-1 Pantalla principal del software KeilUvision
83 | P á g i n a
KeiluVision es una herramienta específicamente desarrollada para probar o desarrollar en
microprocesadores como el ARM7 y está enfocado a crear programas en código C o ensamblador para el
micro procesador, compilarlos, emularlos o ejecutarlos sobre el propio micro procesador en caso de tenerlo
físicamente.
El software también tiene la función de mostrar una emulación del tiempo que consume el microprocesador
en un conjunto de operaciones, por lo que se pueden tomar mediciones de tiempo directamente desde el
procesador siendo éstas casi completamente fiables.
4.1.3 Lenguaje de programación C
Aunque actualmente el auge de la tecnología Java está en aumento para los teléfonos móviles, es cierto que
la gran mayoría de los códigos escritos en C o C# pueden ser convertidos con relativa facilidad a archivos .jar,
ya sea de manera manual o con los software de conversión que actualmente existen de manera gratuita,
además de algunas terminales poseen simuladores de lenguaje C.
Basándonos en lo anterior, se ha decidido usar el lenguaje de programación C debido a que al no ser un
lenguaje propio de una sola plataforma puede reutilizarse en muchas otras, además de que el software de
desarrollo utilizado permite su utilización sobre las pruebas en microprocesadores. C es un lenguaje de
programación no orientado a objetos simple y flexible. Utiliza tipos primitivos para evitar utilizar
operaciones redundantes y punteros para referenciar posiciones de memoria. A pesar de ser un lenguaje no
orientado a objetos, permite el encapsulado y polimorfismo de una manera rudimentaria gracias a los
punteros a funciones y variables estáticas
4.1.4 Rijndael Inspector 1.1
Rinjndael Inspector51
es un software diseñado por Enrique Zabala para el proyecto Cryptool. En él se
permite, aplicando el algoritmo AES, realizar el cifrado o descifrado de un bloque de 128 bits, utilizando una
clave de una longitud de 128 bits. Se puede introducir manualmente el valor tanto del bloque a cifrar o
descifrar como de la clave.
Ha sido especialmente de utilidad porque no sólo encripta o desencripta los datos, sino que muestra todos
y cada uno de los valores que adquiere el Estado, además de las diferentes subclaves, es decir, que muestra
los resultados después de cada operación realizada (SubBytes, MixColumns, etc).
51 http://pacofdez.hostzi.com/swf/Rijndael-Inspector-v1.1-esp.swf
84 | P á g i n a
4.1.5 Battery Monitor Widget
Battery Monitor Widget es una aplicación para teléfonos que tengan como base un sistema android, más
que un widget, es una herramienta que de análisis completo acerca de la batería y su uso. El pequeño
widget de 1x1 nos muestra lo más importante de la batería. Aparece el estado de la batería en porcentaje
así como la corriente de descarga en mA (Miliamperios). Los valores son predeterminados y podemos
ajustarlo a nuestra elección.
La calibración manual nos asegura datos más precisos. Podemos especificar la capacidad de la batería y la
tensión de salida del cargador. Estos valores se determinan de manera automática pero podemos cambiarlo
manualmente para minimizar el margen de error.
Lo interesante de esta aplicación para nuestros fines es su apartado de estadísticas, en el se presenta todo lo
relacionado con la batería ya sea el consumo medio o el tempo estimado para volver a cargar la batería. Una
característica muy práctica es la que nos muestra la estimación de la duración de la batería en base al uso de
aplicaciones (una a una), WiFi, encendido/apagado de la pantalla, bluetooth, etc. todo lo que se quiera
calcular en base al gasto de la batería está contemplado. No hay lugar a duda. Así podemos saber, por
ejemplo, que aplicación es la que más consume y ejecutarla de forma más racional para optimizar el uso de
la batería. Tiene un historial con una visión perfecta de los procesos de carga y descarga, Los procesos se
muestran en una tabla en intervalos de 10 minutos. Además todos los datos se pueden exportar y podemos
controlar un número infinito de baterías y aplicaciones.
Dado que la presente tesis implica hacer un análisis de la batería con las mejoras aplicadas, con esta
herramienta se puede saber con exactitud qué proceso consume más y cuanto exactamente. Battery
Monitor Widget es fluido y estable. El consumo de batería que hace esta aplicación es mínimo.
Figura 4-2 Pantalla principal de Battery Monitor Widget
85 | P á g i n a
4.2 Implementación de AES
En esta primera fase únicamente se busca implementar el AES en todos los posibles tamaños de la clave
respetando siempre las especificaciones del NIST.
4.2.1 Funcionamiento del programa
Se ha realizado un diagrama para explicar el funcionamiento general del programa de manera que pueda
facilitarse su explicación:
Figura 4-3 Diagrama de funcionamiento del algoritmo52
El programa ejecuta el algoritmo AES tanto para cifrar como para descifrar con tamaños de clave de 128,
192 y 256 bits. Con el objetivo de que la aplicación sea lo más eficiente posible, dentro de la inicialización
de periféricos del software ARM se configura la frecuencia de trabajo del microprocesador y del periférico.
De este modo la ejecución se realizará a la máxima velocidad.
Hay una primera fase (llamada toma de parámetros) en la que el programa inicializará la mayor parte de las
herramientas del microprocesador y establecerá las características de la operación.
En la toma de parámetros hay una correspondencia entre caracteres y funcionamiento, esto está delimitado
por la siguiente tabla:
52 L.C.I Nancy Paola Galvez Meza
86 | P á g i n a
Tabla 4-1 parámetros de inicialización
Carácter recibido Modo de funcionamiento
‘d’ o ‘D’ Descifrado
Cualquier otro Cifrado
‘3’ Tamaño de clave de 256 bits
‘2’ Tamaño de clave de 192 bits
Cualquier otro Tamaño de clave de 128 bits
Se procede con la segunda fase (llamada ejecución) en la que el programa generará las subclaves de la ronda
y esperara el bloque de cifrado, le aplicara las operaciones de cifrar y descifrar y devolverá los caracteres
resultantes del proceso.
Después de introducir el carácter que define si se va a cifrar o descifrar y tras obtener la clave, el programa
permanecerá a la espera de bloques a cifrar o descifrar, los cuales devolverá cifrados o descifrados.
4.2.2 Distribución del programa
El programa realizado se ha dividido en diferentes archivos. Cada uno contiene funciones y variables
clasificadas por su utilidad. Los archivos del programa principales y donde se aplicaron las mejoras son
aes.c, y main.c.
En la siguiente tabla se indica que funciones y variables se encuentran en cada uno de ellos. Además ofrece
una breve descripción sobre la utilidad y el funcionamiento de algunas de las funciones o variables.
Tabla 4-2 resumen de funciones de la implementación del algoritmo AES
aes.c Variables int sbox[256] Tabla S-box.
int isbox[256] Tabla S-box inversa.
estado [4][4] Matriz de estado sobre la que se irán
aplicando todas las operaciones durante el proceso
87 | P á g i n a
de cifrado.
roundKey[240] Arreglo con el conjunto de todas las
subclaves de ronda.
int Rcon[255] Constantes Rcon
Funciones setEstado(entrada[16]) Coloca los componentes del
arreglo de entrada en sus lugares dentro de la
variable estado[4][4].
getEstado() Devuelve un puntero al arreglo de la
matriz de estado
keyExpansion() Crea todas las subclaves de ronda a
partir del contenido de la variable clave del archivo
main.c
addRoundKey(ronda)Realiza la operación
AddRoundKey entre la matriz de estado y la
correspondiente subclave de ronda depositando el
resultado en la matriz de estado
subBytes()Estas operaciones se corresponden con
las operaciones principales del algoritmo AES y sus
inversas.
Trabajan directamente sobre la matriz de estado y
no necesitan ningún parámetro.
invSubBytes()
shiftRows()
invShiftRows()
mixColumns()
invMixColumns()
main.c Variables Cifrar 1 – cifrar, 0 – descifrar.
longitudClave clave[32] Arreglo que guarda la clave
de cifrado. Su tamaño es el mayor posible, en caso
de que la clave no sea de la mayor longitud (256
bits) las últimas posiciones del arreglo se ignorarán.
88 | P á g i n a
claveRecibida[64] Almacena los caracteres recibidos
como clave.
palabraRecibida[32] Almacena los caracteres
recibidos como bloque a cifrar.
bloque[16] Arreglo que guarda el bloque a cifrar
tras averiguar el significado de los caracteres
recibidos.
palabraProcesada[16] Guarda el bloque resultante
del proceso de cifrado/descifrado.
numeroRondas
nuevaPalabra Indica cuando se ha recibido todo un
bloque por el puerto serie
Funciones fijaBloque()
Averigua el valor real de los caracteres ASCII
recibidos como bloque de cifrado y lo almacena en
la variable bloque.
fijaClave()Averigua el valor real de los caracteres
ASCII recibidos como clave y lo almacena en la
variable clave.
leeCifra(caracter) Devuelve el valor real de un
carácter ASCII
leeChar(valor) Devuelve el carácter ASCII de un
valor numérico
main() Método main del programa. Comienza a
partir de él.
En conjunto, estos archivos nos permiten ejecutar el algoritmo AES con un funcionamiento que sigue paso
por paso las especificaciones de Daemen y Rijmen explicadas en el capítulo 2 y 3. El detalle de la estructura
del programa se puede visualizar en los anexos.
4.3 Mejoras de rendimiento
Después de implementar el algoritmo AES y de ejecutarlo, el principal objetivo es mejorar su velocidad, ya
89 | P á g i n a
sea aprovechando características del microprocesador o del mismo algoritmo y poder utilizar esas mejoras
en futuras. De esta manera las mejoras podrán ser ubicadas en cualquier otra implementación del
algoritmo. Es por esto que se ha preferido enriquecer las funciones básicas del algoritmo en vez de la
presentación o captura de datos dentro del algoritmo AES.
4.3.1 Complejidad temporal del Algoritmo
Se denomina complejidad temporal a la función T(n) que mide el número de instrucciones realizadas por el
algoritmo para procesar los n elementos de entrada. Cada instrucción tiene asociado un costo temporal.
Afecta al tiempo de ejecución el orden en que se procesen los elementos de entrada. Podría considerarse
que los valores de los n casos que se presentan como entrada son los correspondientes: a un caso típico, o a
un caso promedio, o de peor caso. El peor caso es el más sencillo de definir (el que demore más para
cualquier entrada), pero si se desea otros tipos de entrada habría que definir qué se considera típico, o la
distribución de los valores en el caso promedio.
Para analizar el algoritmo y para comprobar que las mejoras consigan el objetivo, se han efectuado
mediciones de tiempo en la ejecución de cada una de las funciones que conforman el algoritmo. El
programa Keil uVision4 de ARM aporta una herramienta que nos permite simular el funcionamiento del
programa y nos ayuda a saber cuánto tiempo tarda en efectuar todas y cada una de las operaciones.
4.3.2 Análisis del algoritmo AES
Proponer mejoras de tiempo de ejecución en el algoritmo es tomar en cuenta el hecho de que se debe
comprender cómo trabaja en cada una de sus fases, para eso se realizó un análisis del mismo dividido en dos
partes.
En principio de tomaron mediciones en el tiempo de ejecución de cada una de las funciones y se
compararon entre ellas para determinar cuál es la que consume más tiempo de ejecución y por tanto
centrarse en la mejora de ésta, después se analiza la manera en que el algoritmo está diseñado para
verificar que tipo de mejora suponen una mayor eficiencia en el tiempo de proceso del mismo.
4.3.2.1 Análisis de tiempos de AES
La primera medición base del algoritmo se realizó con base en un sólo bloque de cifrado en los tres posibles
tamaños de clave a los que se ha referido en el presente documento. Los resultados de estas mediciones se
pueden observar en la siguiente tabla:
90 | P á g i n a
Tabla 4-3 Medición del tiempo en cada función del algoritmo AES medidos en microsegundos (µs)
Tamaño de clave 128 bits 192 bits 256 bits
Inserción de datos 12.935µs 12.935µs 12.935µs
KeyExpansion 156.24µs 178.187µs 213.716µs
AddRoundKey 95.5µs 115.5 µs 129 µs
SubBytes 73.333µs 88µs 102.667µs
ShiftRows 14.5µs 16.8µs 19.113µs
MixColumns 82.550µs 106.45µs 129.99µs
InvShiftRows 13.333µs 16.06µs 19.067µs
InvSubBytes 72.35µs 87.89µs 103µs
InvMixColumns 1246µs 1519.µs 1796µs
La grafica siguiente muestra de manera más clara cuál de las funciones del algoritmo tiene más peso en su
tiempo de ejecución:
Figura 4-4 Proceso para un bloque de cifrado dependiendo del tamaño de clave
91 | P á g i n a
En la gráfica anterior se observa que la función con más peso es InvMixColumns, ocupando un 75% del
total del tiempo. También se puede ver que la extracción e inserción de los datos y las funciones
ShiftRows e InvShiftRows tienen muy poco peso en funcion al tiempo de ejecución que toma cada
una.
Hay algo importante en la función KeyExpansion , pese a que es la segunda función con más tiempo en
ejecución, está se ejecuta solo una vez durante todo el proceso, por tanto aunque el tamaño de los
aumente, el tiempo se mantendrá constante.
Con base en los resultados de tiempo de ejecución anteriores se concluyeron las siguientes premisas:
1. La función InvMixColumns es la que debe mejorarse para reducir al máximo su tiempo de
proceso.
2. Las funciones ShiftRows e InvShiftRows serán revisadas pero sus mejoras no son
prioritarias.
3. En caso de que se ejecuten pocos bloques de cifrado la función KeyExpansion tiene
importancia. Se incluirá por esto una mejora en el tiempo, sin embargo como al aumentar los
bloques el peso de esta función tendera a cero no será tomada como prioridad.
4. El resto de funciones serán revisadas para reducir al máximo posible sus tiempos de proceso.
4.3.2.2 Análisis del programa AES
Para lograr una mayor eficiencia del algoritmo se ha analizado el código creado, las operaciones propias del
algoritmo y las posibilidades de desarrollo. La idea de la eficiencia de los algoritmos se basa en la premisa de
que el éxito de un algoritmo no debe de depender en ningún caso de la velocidad ni del potencial del
sistema en que se ejecute. Un algoritmo eficiente siempre tiene que ser mejor que otro que no lo es, aun en
el caso de que el segundo se ejecute en un sistema claramente superior.
Se han descubierto varios puntos fuertes que se pueden explotar como la posibilidad de trabajar con
palabras de 32 bits con la que cuenta nuestro microprocesador y puntos débiles que se pueden depurar, las
cuales serán expuestas en cada una de las correspondientes funciones. Por tanto se han descubierto
diferentes tipos de mejoras que se pueden utilizar en distintas partes del programa y funciones del
algoritmo.
Las mejoras que más se van a utilizar y que se espera que traigan mejores resultados son las siguientes:
Ejecución del algoritmo con 32 bits de palabra. Esta es una de las mejoras que más aportaría a la
reducción de tiempo. Se basa en utilizar toda la capacidad del microprocesador y ejecutar las
92 | P á g i n a
operaciones tomando 32 bits en vez de 8, por lo que idealmente reduciría, en teoría, a la cuarta
parte el número de operaciones realizadas debido que en un solo bloque de 32 bits se tomarían 4
de las operaciones (de 8 bits cada una) con las que actualmente trabaja el algoritmo.
Loop unrolling. El loop unrolling o loop unwinding es una técnica de programación muy usada que
se basa en “desenrollar” bucles para que no haya necesidad de realizar las operaciones que se
realizan al índice contador del bucle o que dependen de él al estar precalculadas. Un inconveniente
que tiene el loop unrolling es que al “desenrollar” los bucles se realiza mayor uso de memoria, por
esto, sólo se utilizará esta técnica para bucles cuyo “desenrollado” no conlleve un notable
incremento de memoria
Eliminación y/o simplificación de operaciones repetidas. Analizando minuciosamente las
especificaciones de AES de Daemen y Rijmen se han encontrado algunas operaciones que se
realizan varias veces. Eliminando estas operaciones se puede reducir el tiempo de una manera
notable sin que esto afecte la manera en que el algoritmo trabaja ni su integridad, se debe recordar
que los cambios se están contemplando para ser aplicados en una implementación para móviles,
no en un algoritmo nuevo en sí.
Eliminación de variables y operaciones asociadas. En los códigos de programación suelen existir
variables que son recursos del programador. Estas variables facilitan la programación pero hacen
que haya más operaciones. Por tanto, en algunos casos, si se eliminan se gana en tiempo de
cómputo global. Nuevamente, se debe tener mucho cuidado de no afectar la integridad del
algoritmo.
Estas son las técnicas que se utilizarán. A continuación se describe como se implementaron en las
diferentes partes del programa y cuales resultados se obtuvieron.
4.3.3 Implementación de las mejoras
Tras analizar cómo y dónde poder minimizar al máximo el tiempo de proceso del programa, en los siguientes
apartados se procederá a implementar esas mejoras y analizar sus resultados. Para ello empezaremos con
una modificación estructural que nos permitirá utilizar toda la capacidad del microprocesador.
4.3.3.1 Utilización de toda la capacidad del microprocesador
Tras este apartado se irán comentando las múltiples mejoras que se han conseguido. No obstante el
principal recurso para llegar hasta ellas ha sido el uso de toda la capacidad del microprocesador, por lo que
en este apartado se explica cómo se ha logrado usar esta capacidad.
93 | P á g i n a
Analizando el algoritmo AES notamos que, como hemos explicado anteriormente, trabaja con operaciones a
nivel de 8 bits, ya que cada uno de los elementos de la matriz de estado ocupa 8 bits. Sin embargo nosotros
contamos con un microprocesador capaz de trabajar con palabras de 32 bits. Por tanto cada vez que el
microprocesador realiza una operación con un único byte está desaprovechando gran parte de su capacidad.
Nuestro objetivo principal será por tanto conseguir que el microprocesador trabaje con 32 bits en lugar de
hacerlo con un único byte. Para hacer esto habrá que modificar ampliamente la estructura de nuestro
programa.
En su primera versión, el cifrado se basaba en colocar en una matriz de cuatro por cuatro bytes los
elementos de la matriz de estado y realizar una serie de operaciones sobre ella.
Lo primero a intentar es sustituir la matriz por un arreglo de 4 variables de 32 bits, que deberían almacenar
cada una de las filas de la matriz de estado. Sin embargo, analizando las diferentes posibilidades se eligió
usar una versión traspuesta de la matriz de estado, la cual quedo representada por un arreglo de cuatro
enteros que contendrán los valores de sus filas.
Por tanto si la distribución de los bytes de la matriz de estado anteriormente era esta:
Con las mejoras propuestas, la matriz transpuesta se verá de la siguiente manera:
Y por tanto se almacenara en este orden
A continuación se procederá a describir todas las modificaciones que se han efectuado en el código y sus
aportaciones en tiempo por orden de ejecución. La comparación entre antes de las mejoras y el después
están en el anexo.
94 | P á g i n a
4.3.3.2 Mejoras en la extracción e inserción de los datos
En este apartado se denota la introducción de dos mejoras en la extracción de los datos y la inserción.
Al modificar la matriz de estado se afecta el establecimiento de ella (función setEstado()) y a la
extracción de los datos (getEstado()). Por ello se deben modificar estas funciones. Una vez cambiada
la función getEstado() se han aprovechado las características del mismo para desenrollar un bucle y así
reducir los cálculos. En programación los bucles son un recurso que se utiliza constantemente pero para
mantener una eficiencia en el tiempo de ejecución debemos mantenerlos al mínimo.
En la siguiente tabla se puede ver la eficiencia conseguida después de estos cambios. Esta reducción
representa el tiempo que el microprocesador deja de usar para realizar las operaciones en la versión
mejorada y el porcentaje que este representa respecto del tiempo que tardaba antes de las mejoras.
Tabla 4-4 Mejoras de rendimiento en la extracción de datos
Tiempo de inserción de datos Tiempo de extracción de datos
Original 4.759 µs 8.054 µs
Mejora de 32 bits 2.148 µs 7.145 µs
Loop Unrolling N/A 5.344 µs
Reducción total en el tiempo 2.611 µs (54.86%) 2.71 µs (33.65%)
Observamos que tras estas dos mejoras tanto la extracción como la inserción de datos mejoran
notablemente aunque no se consideraba estrictamente necesario conseguir su reducción debido a su poco
peso en la estructura del algoritmo.
95 | P á g i n a
4.3.3.3 Función KeyExpansion (keyExpansion())
El principal problema encontrado en la función KeyExpansion fue que al utilizar el formato de 32 bits
es que las claves también deben que estar traspuestas (como en la matriz de estado).
Por lo tanto se pensaron dos soluciones:
1. Adaptar a 32 bits el algoritmo de generación de claves y posteriormente trasponer los resultados.
2. Modificar el algoritmo de generación de claves para obtener directamente las claves traspuestas
La opción uno es la más sencilla, ya que trasponer una matriz es un cálculo muy básico, sin embargo la
premisa es la eficiencia, por lo tanto se deben probar ambas soluciones para elegir la más efectiva.
Se procedió a diseñar el algoritmo de generación de claves traspuestas. Este proceso no es sencillo y
tampoco es demasiado práctico puesto que la generación de claves utiliza palabras anteriores para la
obtención de una nueva palabra y al estar traspuestas debe tomar parte de varias palabras distintas en cada
paso. En la figura, las palabras sin trasponer aparecen en vertical y las palabras traspuestas serían el
contenido de los rectángulos horizontales en rojo.
Figura 4-5 Generación de claves transpuestas
Tras desarrollar estas dos soluciones obtenemos los resultados que aparecen en la tabla
96 | P á g i n a
Tabla 4-5 Mejoras en la función keyexpansion
Tamaño de la clave 128 bits 192 bits 256 bits
Tiempo original 157.250 µs 176.180 µs 211.620 µs
Opción 1
(transposición)
67.016 µs (29.950 µs) 76.780µs (35.320 µs) 96.420 µs (40.693 µs)
Opción 2 41.067 µs 63.375 µs 57.520 µs
Reducción total de
tiempo
116.183 µs (73.88%) 112.782 µs (64.03%) 154.215 µs (72.82%)
La opción 1 reduce enormemente el tiempo de proceso. No obstante, el tiempo que la función invierte en
trasponer los resultados es muy alto.
En la segunda opción se realiza la trasposición implícitamente. En este caso, el tiempo total es bastante
similar a la primera pero sin tener el tiempo alto der la trasposición.
Con lo anterior se nota como en el caso de 192 bits se obtienen resultados menos favorables que en los
casos de 128 y 256. Esto es debido a que se dificultan los cálculos porque cada 6 palabras hay que sumar la
constante rcon pero las subclaves son de 4 palabras, y estos números no son múltiplo el uno del otro, de
esta manera no es sencillo definir en qué punto hay que sumar la constante.
Por tanto, como no invierte tiempo en trasponer los resultados, la opción 2 resulta mucho más eficiente
consiguiendo llegar a invertir solamente la cuarta parte de tiempo que invertía antes de esta mejora.
97 | P á g i n a
4.3.3.4 Función AddRoundKey (addRoundKey(r))
Esta función se encarga de mezclar la matriz de estado con la subclave de ronda, por lo que se apoya en la
mejora aplicada a la función KeyExpansion en el apartado anterior.
En esta función se han aplicado varias mejoras: La adaptación al funcionamiento en 32 bits y, loop unrolling
y eliminación de operaciones sencillas. Lo anterior se ha basado en sumar la subclave y la matriz de estado
en palabras de 4 elementos en lugar de hacerlo de elemento en elemento.
El resultado de estas mejoras queda reflejado en la tabla siguiente:
Tabla 4-6 Mejoras Addroundkey
Por ronda 128 bits 192 bits 256 bits
Tiempo original 8.317 µs 94.458 µs 112.00 µs 129.12 µs
Tiempo mejora de 32 bits 2.090 µs 22.990 µs 29.536 µs 33.117 µs
Loop unrolling 1.183 µs 15.095 µs 17.865 µs 20.625 µs
Reducción de tiempo 7.134µs
(85.93%)
79.363µs
(84.01%)
94.135µs
(83.00%)
108.495
(84.01%)
Conviene notar que la función AddRoundKey es llamada un número de veces igual al número de rondas
más uno, por lo que la reducción real será aproximadamente dicho número (11, 13 o 15) multiplicado por la
reducción por ronda.
La mejora que más funciona en Addroundkey fué ejecutar las operaciones a nivel de 32 bits. No
obstante, sólo con las mejoras de loop unrolling y de operaciones sencillas se llega a aplicar una reducción
de tiempo de casi el 50% en el caso de clave de 256 bits, lo cual es un porcentaje bastante alto. Para concluir
se puede ver que la versión original tardaba muy poco tiempo por lo que era más difícil conseguir mejoras
notables. Aún así se ha llegado a una reducción de tiempo del 85.93%.
4.3.3.5 Función SubBytes (subBytes())
La función SubBytes se encarga de introducir lo que se llamaría comúnmente “confusión” a todo el
proceso de cifrado/descifrado del algoritmo pues realiza la sustitución de los bytes de la matriz de estado
con los correspondientes usados en una tabla S-Box (esta puede verse en los anexos).
La mejor manera de aplicar una mejora de funcionamiento sería creando, tomando como base la tabla S-
98 | P á g i n a
Box actual , una de 32 bits para realizar 4 consultas por ronda. Está debería tener 2 32
diferentes entradas y
ocuparía 32 x 2 32
bits , el siguiente calculo ilustra lo anterior:
32x232
= 1.374389535 x 1011
bits
1.374389535 x 1011
bits / 8.589.934.592 bits/GB = 16 GigaBytes.
El procesador ARM con el que estamos trabajando no cuenta con una memoria de ese tamaño, aunque hay
maneras de usar otro tipo de memorias, al estar enfocado para un dispositivo móvil no sería conveniente
forzar de esa manera la utilización del algoritmo. Sobre todo porque lo anterior supondría únicamente una
reducción de 6- 7µs por ronda.
Como solución se adaptó la función a 32 bits utilizando la tabla S-Box sin cambiar el número de entradas,
sino más bien usando números enteros al convertir los valores a 32 bits añadiendo ceros a la izquierda en
vez de los bytes almacenados hasta ahora. Esto agiliza la utilización de los valores.
Con lo anterior, se mantiene el número de consultas a la tabla en 16 pero se reduce el número de
modificaciones de la matriz de estado a 4 en lugar de las usuales 16. También se ha aplicado loop unrolling y
la mejora de reducción de algunas operaciones sencillas.
Tabla 4-7 Mejoras subBytes().
Por ronda 128 bits 192 bits 256 bits
Original 7.350 µs 73.350 µs 88.020 µs 102.680 µs
Mejora 32 bits 4.450 µs 43.333 µs 52.000 µs 60.667 µs
Loop unrolling 3.487 µs 34.835 µs 41.800 µs 48.767 µs
Reduccion de
tiempo
3.863 µs
(52.4%)
38.515 µs
(52.5%)
46.22 µs
(52.5%)
53.913 µs
(52.4%)
Como podemos ver se ha llegado a reducir el tiempo de proceso en un 52.5% sin necesitar el uso de una
exagerada memoria.
4.3.1.1 Función ShiftRows (shiftRows())
La función ShiftRows se encargaba de rotar las filas de la matriz de estado un número de bytes en
función del número de fila, estos números eran todos distintos para añadir difusión. Con la trasposición de
la matriz de estado habrá que modificarla para que roten las columnas en vez de las filas como estaba en un
inicio.
99 | P á g i n a
Al rotar las columnas, cada una de ellas está almacenada en una variable de 32 bits y el ARM
microprocesador cuenta con una operación que se encarga de rotar los bits de una variable.
En otras palabras, debido a la adaptación al funcionamiento en 32 bits se deberá sustituir a 4 rotaciones de
enteros en vez de los 16 movimientos que se tenían en un inicio. Se ha eliminado una variable y funciones
simples que se tenían con ella.
Tabla 4-8 Mejoras en ShiftRows
Por ronda 128 bits 192 bits 256 bits
Original 1.33 µs 13.33 µs 16.051 µs 18.667 µs
Mejora 32 bits 1.117 µs 11.556 µs 14.015 µs 16.412µs
Loop unrolling 0.883 µs 8.950 µs 10.715 µs 12.365 µs
Reduccion de
tiempo
0.450 µs
(33.76%)
4.38 µs
(33.74%)
5.336 µs
(33.74%)
6.302 µs
(33.71%)
Se puede apreciar como en esta mejora se consiguió, en promedio, un tiempo 33.75% más eficaz. Cabe
mencionar que a pesar de que este valor es, hasta ahora, el menor conseguido con respecto a las secciones
anteriores, pero también se tiene en cuenta que la operación era de una magnitud inferior, por tanto su
mejora es más difícil y menos importante en jerarquía (aproximadamente un 5% en el tiempo total de
ejecución del algoritmo).
Por otro lado, el microprocesador tarda más en efectuar una operación de rotación de bits en comparación
de una asignación de variable, y una de las mejoras de esta función se basa en sustituir 16 operaciones de
sustitución por cuatro de rotación.
4.3.3.6 Función MixColumns (mixColumns())
La función MixColumns es un reto por si misma debido a que es una de las funciones con mas pasos, por
tanto se ha hecho un análisis y rediseño cuidadoso para lograr adaptarla al funcionamiento de 32 bits.
El resultado de la función puede observarse mejor en las siguientes operaciones:
Y0 =02 *X0 ⊕ 03*X1 ⊕ X2 ⊕ X3
Y1= X0 ⊕ 02 *X1 ⊕ 03*X2 ⊕ X3
100 | P á g i n a
Y2=X0 ⊕ X1 ⊕ 02*X2 ⊕ 03*X3
Y3=03*X0 ⊕ X1 ⊕ X2 ⊕ 02*X3
En lo anterior xi delimitan las columnas de la matriz de estado traspuesta antes de la función
MixColumns e yi después de ella y correspondiéndose el operador * al producto en (GF 28) 53 - llamado
campo de Galois- realizado en paralelo byte a byte.
Lo más sencillo para calcular lo anterior es usar acumuladores, es decir variables que funjan con esta función
y usar xi para almacenar el producto 02 * Xi. Esto puede ilustrarse en la siguiente tabla:
Tabla 4-9 Pasos de mixcolumns
La principal mejora de este apartado ha sido que la función MixColumns ahora funciona a 32 bits
mediante estos tres pasos. Ahora para maximizar los resultados se deberá modificar de igual manera
xtime(x).
El xtime(x) tiene como función realizar el producto de x por 2 en (GF 28). Se ha adaptado para que
funcione de igual manera que la función anterior con palabras de 32 bits y de esta manera es posible realizar
la operación una vez en vez de 4 como estaba anteriormente ya que no es necesario separar los bytes de
cada columna.
Para finalizar con este apartado es conveniente mencionar que se eliminaron 4 bucles, una variable y
operaciones que pudieron reducirse usando la técnica de loop unrolling.
53 En álgebra abstracta, un cuerpo finito, campo finito o campo de Galois (llamado así por Évariste Galois) es
un cuerpo definido sobre un conjunto finito de elementos.
101 | P á g i n a
Tabla 4-10 Mejoras en mixcolumns
Tiempo por ronda Clave 128 bits Clave de 192 bits Clave de 256 bits
Tiempo original 9.950 µs 89.410 µs 109.570 µs 129.420 µs
Tiempo 32 bits 11.300 µs 101.250 µs 123.924 µs 146.500 µs
Tiempo mejora
xtime(x)
7.140 µs 65.987 µs 80.751 µs 95.250 µs
Tiempo loop
unrolling
4.254 µs 39.870 µs 48.500 µs 57.610 µs
Reducción de
tiempo
5.696 µs
(55.34%)
49.54 µs
(55.33%)
61.07 µs
(55.32%)
71.81 µs
(55.34%)
Con las mejoras se logro una reducción del 55.33% con respecto al tiempo original de la función
MixColumns. Además la mejora de xtime(x) ha sido clave para permitir que la mejora de 32 bits
aporte sus beneficios y la técnica de loop unrolling ha hecho posible aprovechar todo el potencial de la
ejecución en 32 bits.
Como medida de comparación, se puede ver que el tiempo ahorrado es prácticamente lo equivalente al
tiempo que conjuntamente se usa en las operaciones AddRoundKey, SubBytes y ShiftRows.
4.3.3.7 Función InvShiftRows (invShiftRows())
InvShiftRows se encargaba de rotar las columnas de la matriz de estado transpuesta, por tanto su
función inversa debe rotarlas en un sentido opuesto. Por tanto las mejoras aplicadas a la función
InvShiftRows son similares a las de la función ShiftRows basándonos en la adaptación al
funcionamiento en 32 bits, en el loop unrolling, la eliminación de variables y el prescindir operaciones
sencillas.
102 | P á g i n a
Tabla 4-11 Mejoras en invshiftrows
Tiempo por ronda Clave de 128 bits Clave de 192 bits Clave de 256 bits
Tiempo original 1.33 µs 13.33 µs 16.12 µs 18.657 µs
Mejora 32 bits 1.117 µs 11.67 µs 13.99 µs 16.450 µs
Loop unrolling 0.88 µs 8.84 µs 10.00 µs 12.350 µs
Reducción de
tiempo
0.45 µs
(33.75%)
4.49 µs
(33.74%)
6.12 µs
(33.74%)
6.307 µs
(33.74%)
Después de las mejoras se logra un ahorro de tiempo de un 33.75%, esta reducción puede parecer pequeña
pero esta función tiene muy poco peso en el tiempo de proceso de todo el descifrado.
4.3.3.8 Función InvSubBytes (invSubBytes())
En este apartado comenzaremos con decir que la función SubBytes y la función InvSubBytes solo se
diferenciaban por el lugar donde los bytes eran sustituidos: una tabla inversa S-Box en lugar de una tabla
normal S-box.
Basados en esa premisa en la función InvSubBytes se pueden aplicar las mejoras de manera
parecida a como se hizo en la función SubBytes convirtiendo la tabla iS-Box en una tabla de valores
enteros (32 bits) añadiendo ceros por la izquierda a sus valores.
Tabla 4-12 Mejoras en inv subytes
Tiempo por ronda Clave de 128 bits Clave de 192 bits Clave de 256 bits
Tiempo original 7.32 µs 73.32 µs 88.100 µs 102.670 µs
Mejora 32 bits 4.34 µs 43.33 µs 52.00 µs 60.670 µs
Loop Unrolling 3.350 µs 34.250 µs 41.605 µs 48.650 µs
Reducción de
tiempo
3.97 µs
(52.6%)
39.07 µs
(52.5%)
46.495 µs
(52.4%)
54.02 µs
(52.4%)
El tiempo se redujo en un porcentaje de 52.5% sin aumentar en gigabytes la memoria utilizada. El tiempo
103 | P á g i n a
de ejecución podría verse más reducido si se utilizara una tabla de 32 bits de entrada, aunque esta tendría
un tamaño de 16 gigabytes, demasiado grande para esta aplicación, no hay hasta el momento un dispositivo
móvil que tenga semejante memoria en la que podría aplicarse esa mejora.
4.3.3.9 Función InvMixColumns (invMixColumns())
A continuación se describirán las mejoras aplicadas a la función InvMixColumns, los resultados y la
explicación de los mismos. Las primeras mejoras son muy similares a las que se aplicaron en la función
MixColumns ya que se basan en la ejecución en palabras de 32 bits, la mejora del macro xtime(x) y
en técnicas de loop unrolling.
Una vez aplicadas las mejoras, la función seguía siendo demasiado pesada pese a que se obtuvo la reducción
de tiempo buscada, esto es debido a que la función InvMixColumns es la función con los cálculos de
más alto nivel en comparación con el resto del algoritmo, por tanto se procedió a darle un segundo análisis
para poder llegar a una optimización adecuada en la misma.
Primeramente, para realizar la función MixColumns se aplicaban a la matriz de estado estas operaciones:
Siendo xi las columnas de la matriz de estado traspuesta antes de la transformación MixColumns e yi
después de la misma y correspondiéndose el operador (*) al producto en (GF 28) realizado en paralelo byte
a byte.
El producto en el campo de Galois es una operación que con coeficientes altos adquiere una relativa
complicación. Afortunadamente, en ese caso los coeficientes de este producto (Marcados en rojo oscuro)
eran solamente 1, 2 o 3, lo cual eludía complicaciones.
Si volvemos a la función InvMixColumns, podemos observar como en este caso las operaciones a aplicar
son estas:
Mientras que para el cifrado en la mitad de los casos los coeficientes no exigen realizar operaciones en (GF
104 | P á g i n a
28) y cuando eran necesarias eran con coeficientes bajos (2 o 3), para el descifrado son necesarias en todos
los casos y con coeficientes más altos (9, 11, 13 o 14).
Antes de la mejora las operaciones en (GF 28) cuando había coeficientes elevados se realizaban con la parte
llamada multiply(x, y) que añadía mucho tiempo de proceso.
La primera modificación fue hacer que esta función funcionara con 32 bits en vez de ocho, como se hizo con
su contraparte xtime(x), esto arrojo buenos resultados, sin embargo invMixColumns seguía siendo
demasiado pesada. Por lo tanto se pensó en tratar de eliminar multiply(x, y) y reducir el número de
operaciones que utilizan xtime(x).
Para lo anterior se simplificaron las operaciones a aplicar separando los coeficientes en potencias de dos
para poder hacer uso de xtime(x) en lugar de multiply(x, y). De esta manera hemos obtenido
estas ecuaciones:
Por ellas InvMixColumns se pueden descomponer en una suma de los coeficientes de MixColumns y
de unos coeficientes más sencillos:
De esta manera se pueden aprovechar las operaciones usadas para calcular la matriz [mixcolumns]
sabiendo que la matriz [A] equivale a:
Lo anterior demuestra que se pueden realizar las operaciones en una sucesión de pasos que se resumen en
las siguientes tablas:
105 | P á g i n a
Los pasos anteriores iguales a los de MixColumns, nos dan la matriz [mixcolumns]. Los siguientes pasos
calcularán 4 * (x0+x2), 4*(x1+x3) y 8*(x0+x1+x2+x3) en el cuarto paso y lo sumarán en el quinto.
Resumiendo lo anterior podemos decir que las mejoras aplicadas han sido la adaptación de
InvMixColumns para que funcione con 32 bits, la mejora de xtime(x) para que sustituya a
multiply(x) y la eliminación de bucles prescindibles.
Tabla 4-13 Mejoras invMixColumns().
Por Ronda Clave 128 bits Clave 192 bits Clave 256 bits
Tiempo original 138.200 µs 1.250 ms 1.500 ms 1.793 ms
32 bits 199.450 µs 1.790 ms 2.190 ms 2.594 ms
Xtime(x) y
multiply(x,y)
54.183 µs 487.90 µs 595.32 µs 703.550 µs
Eliminación de
multiply (x,y)
11.090 µs 99.180 µs 121.20 µs 143.26 µs
Loop unrolling 7.67 µs 68.27 µs 83.46 µs 98.56 µs
Reducción de
tiempo
130.53 µs
(94.46%)
1.173 ms
(94.48%)
1.430 ms
(94.48%)
1.69 ms
(94.47%)
106 | P á g i n a
Los resultados son prácticamente óptimos ya que el tiempo inicial era bastante elevado, esto se nota en que
el tiempo se transforma de microsegundos a milisegundos (En comparación el resto de operaciones no
llegaban a tardar más de 200 microsegundos). Se logro una reducción total del 94.47% .
Cabe notar que luego de mejorarla para funcionar con 32 bits y la mejora de xtime() resulta de gran
importancia, aunque lo que más contribuyo a la mejora fue la eliminación multiply(x,y) y los cálculos
redundantes, llegando a reducir a la quinta parte el tiempo de proceso.
4.3.4 Rendimiento tras la aplicación de todas las mejoras
En este apartado se analizarán las consecuencias de las mejoras descritas anteriormente en el tiempo
total de cifrado o descifrado de un bloque desde la inserción a la extracción de los datos. De esta forma se
obtuvieron los siguientes resultados para el análisis con un bloque de cifrado:
Tabla 4-14 Tiempo total cifrando un bloque
Cifrado 128
bits
Cifrado 192
bits
Cifrado 256
bits
Descifrado
128 bits
Descifrado
192 bits
Descifrado
256 bits
Tiempo
original
460.350 µs 531.133 µs 624.650 µs 1.612 ms 1.988 ms 2.288 ms
Tiempo
mejorado
165.250 µs 207.940 µs 222.44 µs 192.249 µs 240.934 µs 261.434 µs
Reducción
de tiempo
295.10 µs
(64.10%)
326.190 µs
(61.05%)
402.056 µs
(64.37%)
1.419 ms
(88.02%)
1.759 ms
(87.90%)
2.027 ms
(88.50%)
107 | P á g i n a
Figura 4-6 : Tiempo total de cifrado de un bloque
Figura 4-7: Tiempo total de descifrado de un bloque
Lo anterior denota claramente que la reducción varía en función del tamaño que se esté usando en la clave,
está relacionado con la función keyExpansion la cual se ha reducido en mayor o menor medida por
tamaño de la clave, cuando solo ciframos un solo bloque la función adquiere mayor peso, pero al ejecutarse
en mas bloques su peso se verá reducido.
La figura 4.5 denota el tiempo utilizado en cada una de las funciones, cada color representa una de las
108 | P á g i n a
funciones que conforman el algoritmo. Se utilizó una grafica apilada por ser la mejor manera de denotar los
tiempos totales y su correspondiente mejora.
Figura 4-8 Rendimiento de las mejoras en un bloque
La primera columna corresponde al tiempo antes de las mejoras, mientras que la segunda al tiempo
conseguido después de ellas. Se ha logrado reducir el tiempo de cifrado en un 64-65% dejando el tiempo en
unos 230µs aproximadamente.
Las funciones con más peso en el algoritmo son KeyExpansion, AddRoundKey, SubBytes y
MixColumns, por ello, usando el análisis explicado en otros apartados, se centraron las mejoras más
fuertes.
Tomando como premisa que la clave usualmente es del mismo tamaño en todo el proceso y es la misma, al
modificar la función KeyExpansion se ejecutará una sola vez, por lo que estos resultados variarían
cuando se tratara de más de un bloque. Para ilustrar si la mejora ha sido efectiva en más bloques de cifrado
se realizaron mediciones con 10 de ellos en los diferentes tamaños de clave.
Tiempo en microsegundos (µs)
109 | P á g i n a
Figura 4-9 Rendimiento total de las mejoras con 10 bloques
Como la grafica indica, la función KeyExpansion pierde peso , mismo que ocupan las funciones
AddRoundKey, SubBytes y MixColumns, y estas han sido optimizadas en porcentaje de 84%, 52% y
55% respectivamente
Para analizar la eficiencia durante el proceso de descifrado observaremos la figura siguiente:
Tiempo en microsegundos (µs)
110 | P á g i n a
Figura 4-10 eficiencia durante el proceso de descifrado
Al descifrar, la gran mayoría del peso se obtiene de la función InvMixColumns; cabe mencionar que esta
fue la función con más dificultad a la hora de buscar una optimización, afortunadamente se nota el
resultado al finalizar las pruebas. Antes de las mejoras era un tiempo excesivo que podía imposibilitar
realizar aplicaciones rápidas de descifrado.
En la gráfica la reducción de InvMixColumns se visualiza tan alta que el resto de reducciones pasan
inadvertidas aunque se logro una considerable reducción de las mismas.
La reducción total tiene efecto con claves de 128, 192 o 256 bits, a mayor número de bloques a cifrar la
reducción será mayor, puesto que la función KeyExpansion será ejecutada una sola vez y su mejora (75%)
pesará menos que la de InvMixColumns (95%).
Al haber reducido el número de variables y de operaciones, se ha minimizado la cantidad de memoria
utilizada por el código y se ha reducido de 18.852 Bytes a 16.516 Bytes. Esto supone una reducción de más
del 12% en la cantidad de memoria utilizada.
Resumiendo, se ha reducido el tiempo de cómputo y la memoria utilizada.
Tiempo en microsegundos (µs)
111 | P á g i n a
Estas reducciones se han realizado aprovechando las capacidades del microprocesador y las cualidades del
algoritmo, reduciendo tiempos a lo largo de todo el algoritmo pero sobre todo en las funciones que tenían
más peso en la ejecución.
4.3.5 Mejoras al Consumo de energía
Como se mencionó anteriormente la memoria utilizada por el algoritmo en funcionamiento era de 18.852
Bytes originalmente, con las mejoras se redujo a 16.516 Bytes lo cual implica una mejora de un 12.39% con
respecto a la memoria original. Actualmente los teléfonos varían entre 1900 a 2400 mAh lo cual es,
aproximadamente, unas 8 -16 horas de vida utilizando varias funciones. Con estos datos es posible denotar
que al consumir menos memoria la batería es posible ampliar la memoria de la batería. Para entender
mejor como afecta la reducción al consumo de batería es necesario denotar primeramente la manera en
que estas operan.
En ellas es normal el uso del miliamperio hora (mAh), que es la milésima parte del Ah (amperio por hora) o
bien 3.6 C 54
. Esto indica la máxima carga eléctrica que es capaz de almacenar la batería. A más carga
eléctrica almacenada, más tiempo tardará en descargarse. El tiempo de descarga viene dado por la
expresión:
De la misma forma, se puede hallar el consumo eléctrico de un dispositivo:
Una vez denotado lo anterior se utilizó una aplicación para hacer las mediciones sobre el simulador: Battery
Monitor Widget, anteriormente descrita, que ofrece una gran cantidad de datos sobre la batería como el
tiempo estimado de duración, aplicaciones que realizan un mayor consumo, voltaje y miliamperios restantes
y mucha más información avanzada. En lo que respecta al Battery Monitor Widget podemos obtener
información sobre el porcentaje restante y los miliamperios consumidos.
La siguiente tabla muestra la mejora con respecto a la batería:
54 1 Amperio (1 Ah = 3600 Culombios)
112 | P á g i n a
Tabla 4-15 Uso de la batería antes y después de las mejoras en miliamperios
Memoria usada Miliamperio por
hora usado
Porcentaje
mejora
Original 18.852 Bytes 6.06 N/A
Después de
mejoras
16.516 Bytes 4.848 12.39%
Por ejemplo, si una batería posee una carga eléctrica de 2000 mAh (7200 C) con lo anterior se realizaría el
cálculo para saber cuánto tiempo se tardaría dedicando la batería únicamente al proceso de encriptado:
Tiempo de descarga= 2000 mAh (7200 C) / 6.06 mA (21.816 C/h)
La batería tardará 330 horas en descargarse. Con el cambio aplicado consume 4.848 mA (17.4528 C/h), la
batería tardará 412 horas en descargarse. Con esto se comprueba que efectivamente se logro que la
batería durara entre 15 y 20% más lo cual es una excelente mejora para un dispositivo móvil.
4.4 Propuestas a futuro de mejoras para la seguridad
El algoritmo AES es considerado uno de los algoritmos más resistentes a ataques. No obstante siempre
pueden encontrarse vulnerabilidades y como consecuencia pueden aparecer agujeros de seguridad.
Para el algoritmo AES solamente se ha encontrado uno que merezca la pena comentar por su importancia y
ha sido recientemente, a finales de Septiembre de 2011. Según tres expertos 55 realizaron un criptoanálisis
por grafos bipartitos (consistente en dividir el problema en varios problemas menores) y encontraron un
defecto que provoca que AES sea cuatro veces más débil. No obstante, incluso aprovechando este defecto
un ataque resulta computacionalmente inviable, ya que se necesitarían más de 2000 millones de años para
romper una clave de 128 bits mediante esta técnica y fuerza bruta.
Podemos ver cómo a pesar de la búsqueda de defectos que se está realizando, el algoritmo demuestra tener
una gran seguridad. No obstante, los ataques de canal lateral son capaces de eludir la estructura interna del
55 Bogdanov, Andrey, Khovratovich, Dmitry y Rechberger, Christian. Biclique Cryptanalysis of the Full AES. [Citado el: 22 de Enero de
2013.] http://eprint.iacr.org/2011/449.pdf
113 | P á g i n a
algoritmo y hacen viable el criptoanálisis. Por ello en este proyecto se propone mejorar el algoritmo frente a
este tipo de ataques añadiendo máscaras aleatorias a la matriz de estado.
4.4.1 Obtención de números aleatorios
La obtención de máscaras aleatorias exige que nuestro microprocesador cree números aleatorios que se
puedan usar para calcular las máscaras. Existen varias maneras de obtener la aleatoriedad.
4.4.1.1 Módulo de creación de números aleatorios
Algunos microprocesadores como el ARM7 tienen un módulo de creación de números aleatorios (Random
Number Generator, RNG) basado en un par de anillos osciladores de reloj independientes que varían de un
dispositivo a otro dependiendo de la fabricación del componente y de la temperatura del dispositivo.
Según el manual de usuario de estos microprocesadores para utilizar este módulo solo bastaría con
configurarlo correctamente en el inicio del programa mediante el registro POWERDOWN y leer el contenido
del registro de 32 bits RANDOM_NUMBER cada vez que quisiéramos obtener un número aleatorio.
Esta sería manera más oportuna de obtener números aleatorios, no obstante, como el módulo de
generación de números aleatorios no está presente en todos los microprocesadores, se decidió que una
solución sería usar un microprocesadores más genérico e implementar la obtención de números aleatorios
en él ya que es una solución mucho más amplia y se podría aplicar en múltiples plataformas.
4.4.1.2 Funciones srand() y rand()
Existe una librería en C llamada stdlib.h que incluye los métodos rand() y srand() que se encargan de generar
números aleatorios. Su funcionamiento es el siguiente:
int rand(void): La función rand devuelve un número entero de una secuencia de números pseudo-
aleatorios con un periodo de 32 bits como mínimo.
void srand(unsigned int value): Usa el argumento como una semilla para crear una secuencia
nueva de números pseudo-aleatorios que podrán ser retornados por llamadas posteriores a rand. Si
srand() es entonces llamada con el mismo valor semilla, la secuencia de números pseudo-aleatorios será
repetida. Si rand es llamada antes de que se hayan hecho cualquier llamada a srand(), la misma
secuencia será generada.
Por tanto si obtenemos una semilla aleatoria y la cargamos en srand() obtendremos números de 32 bits
aleatorios en las sucesivas llamadas a rand().
El uso de estas funciones implica que nuestro programa utilice 408 bytes más de memoria y que cada
114 | P á g i n a
llamada a la función rand() suponga un incremento de 0.133 microsegundos en el tiempo de ejecución
del programa lo cual significan 0.333 microsegundos en una operación de cifrado o descifrado. Como estos
datos son perfectamente asumibles, se ha tomado ésta como la manera de obtener números aleatorios.
No obstante esta forma de obtenerlos parte de una semilla que tiene que ser prácticamente aleatoria.
4.4.2 Uso de máscaras aleatorias
Para proteger el algoritmo frente a ataques de canal lateral, la solución más oportuna consistiría en añadir
distintas máscaras aleatorias a la matriz de estado a lo largo del proceso de cifrado o descifrado. De esta
manera el consumo de potencia no guarda relación con el mensaje a cifrar o descifrar ni con la clave de
cifrado.
No obstante, la manera de aplicar estas máscaras no debe ser tomada a la ligera, si no que ha de ser
correctamente estudiada para no comprometer lo más mínimo la seguridad del proceso. Tras estudiar
distintas formas de añadir máscaras, debido a su sencillez y efectividad, se considera que la mejor referencia
es la propuesta realizada por Stefan Mangard, Elisabeth Oswald y Thomas Popp en su libro Power Analysis
Attacks: Revealing the Secrets of Smart Cards 56
ya que se adaptó al funcionamiento en palabras de 32 bits
en lugar de 8.
56 Mangard, Stefan, Oswald, Elisabeth y Popp, Thomas. Power Analysis Attacks: Revealing the Secrets of Smart Cards (Advances in
Information Security). s.l. : Springer, 2007. págs. 228-231. ISBN-10: 0387308571.
115 | P á g i n a
116 | P á g i n a
Conclusiones
Uno de los propósitos de este trabajo era determinar cuál era el mejor algoritmo criptográfico tomando
como base el rendimiento y seguridad que este poseía para ser aplicado en un dispositivo móvil. Luego del
análisis de velocidad y seguridad se determino que el algoritmo AES era el más apropiado, además de ser un
estándar aprobado internacionalmente.
Después de hacer un extenso análisis de su proceso se propusieron mejoras en el mismo para lograr un
balance entre rendimiento y consumo energético sin sacrificar la seguridad del mismo, es decir, no se
basaron las mejoras en el proceso de encriptación del algoritmo si no en como lo hacía, con el fin de
obtener una adecuada utilidad para el usuario de cómputo móvil.
El primer objetivo fue implantar el algoritmo AES siguiendo fielmente las especificaciones de Daemen y
Rijmen. Gracias al software de Kiel Visions se logró emular el algoritmo AES en el microprocesador,
consiguiendo que funcionara tanto para cifrar como para descifrar, con cualquier tamaño de clave (128, 192
y 256 bits).
Una vez probado el correcto funcionamiento del algoritmo se trató de mejorar sus tiempos de
funcionamiento. Para ello se realizó un análisis de tiempos para ver cuáles eran los puntos que aportaban
más retardo al algoritmo y un análisis del funcionamiento de las funciones del algoritmo para ver cómo
podrían ser simplificadas, encontrando varias funciones de gran impacto que al ser modificadas mejoraron
de manera significativamente el rendimiento del algoritmo. Lo anterior se logró al pasar de 8 a 32 bits y el
uso de otras técnicas como el loop unrolling o la simplificación de operaciones básicas.
La ejecución de operaciones con palabras de 32 bits en lugar de 8 bits es una adaptación del algoritmo a una
gran cantidad de microprocesadores y con ella teóricamente basta con ejecutar una operación donde antes
se necesitaban cuatro.
Gracias a esto se obtienen unos resultados excelentes, llegando a reducirse el tiempo del cifrado en más de
un 60% y el de descifrado en un 90% consiguiendo además una reducción del 12% en la cantidad de
memoria utilizada. Con base a la memoria que se usaba y su mejora, se denoto que la batería podía
alcanzar una vida entre 15 y 20% más larga en comparación con el tiempo original que el algoritmo
utilizaba. Lo anterior le da al usuario de cómputo móvil una ventaja al poder encriptar su información sin
temor a que este proceso gaste demasiado rápido la vida de una batería promedio (equivalente a 2000
mAh).
Estas mejoras han sido claves para una ejecución eficiente del proceso de descifrado ya que antes de ellas
era demasiado pesado por culpa de la función InvMixColumns.
117 | P á g i n a
Por último, tras haber mejorado el tiempo de ejecución se proponen ideas de mejoras a futuro para el
canal lateral (para evitar ataques de fuerza bruta) y así poder mejorar la seguridad. Cabe mencionar que en
todo el proceso de mejora no se toco la lógica de la seguridad del algoritmo por tanto es igualmente seguro
después de ellas.
Si se tuviera que llevar estas mejoras a producción para un costo real, la parte más interesante seria la
adecuación del algoritmo en distintos lenguajes de programación y la adaptación de las mejoras para ellas.
De todas las mejoras aplicadas las funciones MixColumns() e InvMixColumns() son las que tenían
más peso y más complejidad de aplicación , pero una vez logradas traerían la ventaja de que su adaptación
permitiría que el usuario final ejecutara la aplicación en un teléfono móvil con una batería 20% más
pequeña que los modelos actuales , es decir , conseguiría la misma velocidad y duración de batería con un
teléfono de 1600 mAh comparado con el algoritmo original que obtenía este consumo con una batería de
2000 mAh (diferencia de 400 mAh aproximadamente) .
En términos de costo y basándonos en la tabla comparativa de modelos de smartphone para el mercado
Mexicano actual se tendría la siguiente tabla de modelos y costos en base a la batería:
Modelo Batería Costo (precios al 2013 en pesos
mexicanos)
Nexus 4 2100 mAh $ 7,000
Nokia Lumia 2000 mAh $ 6,600
LG Optimus G 2100 mAh $ 5,300
Blackberry Z10 1800 mAh $ 6,500
HTC One 2300 mAh $ 10,500
Sony Xperia Z 2330 mAh $ 8,600
Iphone 5 1440 mAh $ 7,600
Samsung Galaxy S4 2600 mAh $ 9,000
Samsung Galaxy Note 2 3100 mAh $ 9,200
Motorola Razr Maxx 3300 mAh $ 7,500
118 | P á g i n a
Así se lograría que los usuarios que desearan mantener seguros sus dispositivos pudieran hacer una
inversión entre 8 y 12% más baja (por ejemplo invirtiendo en un teléfono de 1800 mAh de batería en vez de
uno de 2000) en comparación con el costo de un teléfono con una batería mayor sin preocuparse por la
vida de la misma o la memoria utilizada en ellos. Aunque hay muchos otros factores en la elección de un
smartphone y es cierto que no solamente se dedicara la vida de la batería a mantener la encriptación, el
tener la certeza de que mantener los datos seguros sin invertir demasiado es un gran aliciente para la
elección de un usuario final de telefonía móvil.
119 | P á g i n a
120 | P á g i n a
Glosario
AES Advanced Encryption Standard
ARM Advanced RISC Machines
CPU Central Processing Unit
DES Data Encryption Standard
GSM Groupe Spécial Mobile
GF Galois Field
NIST National Institute of Standards and Technology
CIFRADO Técnica que mediante un algoritmo nos permite
pasar de un texto en claro a un criptograma.
CLAVE DE CIFRADO Es un texto o palabra que se utiliza para cifrar un
mensaje, la utilización de claves dan lugar a
criptosistemas de clave secreta.
CLAVE PUBLICA Es un criptosistema que utiliza dos tipos de clave:
una secreta o privada y una pública que está a
disposición de todo el mundo, de modo que se
cifra con una de ella y se descifra con la otra.
CODIFICACION Técnica de cifrar información por medio de
códigos, no por medio de algoritmos.
CRIPTOGRAMA Documento obtenido al cifrar un texto en claro. El
alfabeto del criptograma no tiene por
qué ser el mismo alfabeto que el del texto en claro
DESCIFRADO Técnica contraria al cifrado que mediante un
algoritmo inverso nos permite pasar de
uncriptograma a un texto en claro.
121 | P á g i n a
LOOP UNROLLING El loop unrolling es una técnica de optimización
que consiste en hacer más extenso un bucle
simple reduciendo la sobrecarga por comparación
del bucle y permitiendo una mejor concurrencia.
RED FEISTEL Tipo de estructura que recibe el nombre de su
diseñador y que adoptan algunos algoritmos de
cifrado modernos. Consiste en un conjunto de
operaciones que se aplica sobre un mismo bloque
de datos un determinado número de veces. En
cada una de estas veces, llamadas vueltas de la
red, sólo se trabaja con la mitad de los bits que
componen el bloque de datos y se finaliza la
vuelta permutando ambas mitades para que, en la
siguiente iteración, se opere con la mitad restante
del bloque
TEXTO CLARO O TEXTO PLANO Documento original que se desea proteger
mediante el uso de técnicas criptográficas. Al
conjunto de todos estos textos se le denota como
M
122 | P á g i n a
123 | P á g i n a
Bibliografía
[1] Adleman, L.M.: A subexponential algorithm for the discrete logarithm problem with applications
cryptography. Proc. of the 20th Annual IEEE Symposium on Foundations of Computer Science. IEEE Press,
55-60, (1979).
[2] Agraval, M., Kayal, N., Saxena, N.: Primes is in P. Annals of Mathematics, Vol. 160(2), 781-793, (2004)
Web http://cse.iitk.ac.in/news/primality.html, (2003).
[3] Alexi, W., Chor, B., Goldreich, O., Schnorr, C.P.: RSA and Rabin functions:certeins parts are hard as the
whole. SIAM Journal on Computing, Vol. 17, 194-209, (1988).
[4] Álvarez, R.: Aplicaciones de las matrices por bloques a los criptosistemas decifrado en flujo. Tesis
Doctoral (2005).
[5] Álvarez, R., Tortosa, L., Vicent, J.F., Zamora, A.: A public key cryptosystem based on block upper
triangular matrices. 4ht WSEAS, Proceedings of ISCOCO 2005, 163-168. Tenerife (2005).
[6] Álvarez, R., Tortosa, L., Vicent, J.F., Zamora, A.: An internal security kernel. WSEAS, Proceedings of
Transaction on Business and economics. Venecia (2004).
[7] Álvarez, R., Ferrández, F., Vicent, J.F., Zamora, A.: Applying quick exponentiation for block upper
triangular matrices. Applied Mathematics and Computation, Vol. 183, 729-737 (2006).
[8] Anshel, I., Anshel, M., Goldfeld, D.: An algebraic method for public-key cryptography. Mathematical
Research Letters, Vol. 6, 287-291, (1999).
[9] Bach, E., Shallit, J.: Algorithmic number theory. MIT Press. Cambridge, MA,(1996).
[10] Beckman, B.: Arne Beurling and the Swedish crypto program during World War II, Providence (2002).
[11] Beckman, B.: Códigos secretos. Piramide, Madrid (1990).
[12] Bellare, M., Rogaway, P.: Entity Authentication and Key Distribution. Advances in Cryptology - CRYPTO
1993– Lecture Notes in Computer Science, Vol 773, (1994).
[13] Bellare, M., Desai, A., Pointcheval, D., Rogaway, P.: Relations Among Notions os Security for Public-key
Encryption Schemes. Advances in Cryptology –CRYPTO 1998– Lecture Notes in Computer Science, Vol. 1462,
26-46, (1998).
[14] Bennet, C., Brassard, G.: The dawn of a new era for quantum cryptography: the experimental prototype
is working. SICACT News, Vol. 20, 78, (1989).
124 | P á g i n a
[15] Ben-Or, M., Chor, B., Shamir, A.: On the cryptographic security of single RSA bits. Proceedings of the
15th ACM STOC, 421-430, (1983).
[16] Beth, T., González, S., González, M.I., Martínez, C., Steinwandt, R.: Cryptographic Shelter for the
Information Society: Modeling and Fighting Novel Attacks on Cryptographic Primitives. Techno-Legal Aspects
of Information Society and New Economy, (2003).
[17] Beth, T.: El estado de la Criptografía de Clave Pública a la vista de las posibilidades de la Computación
Cuántica. Actas de la VI Reunión Española sobre Criptología y Seguridad de la Información, VI RECSI, 39-50,
(2001).
[18] Beth, T., Frisch, M., Simmons, G.J.: Public-Key Cryptography: State of the Art and Future Directions.
Lecture Notes in Computer Science, Springer Verlag, (1992).
[19] Beth, T.: The State of Public-Key Cryptography - Not Only After the Invention of Quantum Computers.
Information Security Technical Report, (1999).
[20] Blackley, G.R., Borosh, I.: RSA public key cryptosystems do not always concel messages. Comput. Math.
Appl., Vol. 5, 169-178, (1979).
[21] Blum, M., Miscali, S.: How to generate cryptographically strong sequences of pseudo-random bits. SIAM
Journal on Computing, Vol. 13, 850-864, (1986).
[22] Boneh, D., Venkatesan, R.: Hardness of computing the most significant bits of secret keys in Diffie-
Hellman and related scheme. Advances in Cryptology –CRYPTO 1996– Lecture Notes in Computer Science,
Vol. 921, 129-142, (2001).
[23] Bonilla Palencia E.: Implementación del algoritmo AES sobre arquitectura ARM, (Mayo 2012).
[24] Brillhart, J., Lehmer, D.H., Selfridge, J.L.: New primality criteria and factorizations of 2m+ 1. Math.
Comp., Vol. 29, 620-647, (1975).
[25] Buchmann, J.A., Williams, H. C.: A Key Exchange System Based on Imaginary Quadratic Fields. Journal of
Cryptology Vol. 1, (1988).
[26] Canfield, E.R., Erdos, P., Pomerance, C.: On a problem of Oppenheim concerning Factorisation
Numerorum. J. Number Theory, Vol. 17, 1-28, (1983).
[27] Chor, B., Goldreich, O.: RSA/Rabin least significant bit are1 2+poly(log n) secure. Advances in
Cryptology –CRYPTO 1984– Lecture Notes in Computer Science, Vol. 196, 303-313, (1984).
[28] Churchouse, R.F.: A classical Cipher Machine: The ENIGMA, some Aspects,Its history and Solution.
Institute of Mathematics and its Applications, Vol. 27, (1991).
125 | P á g i n a
[29] Climent, J.J., Ferrandiz, F., Vicent, J.F., Zamora, A.: A non linear elliptic curve cryptosystem based on
matrices. Applied Mathematics and Computation, Vol. 74, 150-164 (2005).
[30] Climent, J.J., Gorla, E., Rosenthal, J.: Cryptanalysis of the CFVZ cryptosystem. Advances in Mathematics
of Communications (AMC) Vol. 1, 1-11 (2006).
[31] Cohen, H.: A course in computational algebraic number theory. GTM 138, Springer. Berlin (1995).
[32] Coppersmith, D., Odlyzko, A., and Schroeppel, R.: Discrete logarithms in GF (p). Algorithmica, 1-15,
(1986).
[33] Coppersmith, D.: Cryptography. IBM J. Res. Develop. Vol. 31, No. 2, (1987).
[34] J. Daemen, "Cipher and hash function design strategies based on linear and differential cryptanalysis,"
Doctoral Dissertation, Marzo 1995, K.U.Leuven.
[35] J. Daemen, L.R. Knudsen and V. Rijmen, "The block cipher Square," Fast Software Encryption, LNCS
1267, E. Biham, Ed., Springer-Verlag, 1997, pp. 149-165. También en
http://www.esat.kuleuven.ac.be/rijmen/square/fse.ps.gz.
[36] J. Daemen, L.R. Knudsen and V. Rijmen, " Linear frameworks for block ciphers,"to appear in Design,
Codes and Cryptography.
[37] J. Daemen and C. Clapp, “Fast hashing and stream Encryption with PANAMA,” Fast Software Encryption,
LNCS 1372, S. Vaudenay, Ed., Springer-Verlag, 1998, pp. 60-74.
[38] ISO/IEC 9797, "Information technology - security techniques - data integritymechanism using a
cryptographic check function employing a block cipher algorithm", International Organization for
Standardization, Geneva, 1994 (second edition)
[39] Deavours, C.A., Kruh, L.: Machine Cryptography and Modern cryptanalysis. Artech House Inc., (1985).
[40] Diffie, W., Hellman, M.: New directions In Cryptography. IEEE Trans. Information Theory, Vol. 22, 644-
654, (1976).
[41] Diffie, W.: The First Ten Years of Public Key Cryptography. Proceedings of the IEEE Vol. 76, No. 5, (1988).
[42] ElGamal, T.: A public key cryptosystem and a signature scheme based on discrete logarithms. IEEE Trans.
Information Theory, Vol. 31, 469-472, (1985).
[43] Ferrández, F.: Sistemas criptográficos de curva elíptica basados en matrices. Tesis Doctoral, 102-103,
(2004).
[44] Fischlin, R., Schnorr, C.P.: Stronger security proofs for RSA and Rabin bitsStronger security proofs for RSA
126 | P á g i n a
and Rabin bits. Journal of Cryptology, Vol. 13, 221-244, (2000).
[45] Goldwasser, S., Bellare, M.: Lecture Notes on Cryptography, (2001).
[46] Goldwasser, S., Miscali, S.: Probabilistic encryption. Journal of Computer and Systrem Science, Vol. 28,
270-299, (1984).
[47] González, M.I., Steinwandt, R.: Obstacles in Two Public-Key Cryptosystems Based on Group
Factorizations. Cryptology. Editors: K. Nemoga, O. Grosek, Tatra Mountains Math. Publications, 23-37,
(2002).
[48] González, M.I., Sparlinski, I.E.: On the security of Diffie-Hellman bits. Proc. Workshop on Cryptography
and Computational Number Theory Singapure 1999. Birkaüser, 256-268, (2001).
[49] González, M.I., Martínez, C., Steinwandt, R.: Un Marco Común para Varios Esquemas de Clave Pública
Basados en Grupos. Actas de la VII Reunión Española sobre Criptología y Seguridad de la Información, VII
RECSI, 353-364, (2002).
[50] González, M.I., Naslund, M., Sparlinski, I.E.: The hidden number problem inextension fields and its
applications. Proc. the 3rd Latin American Theoretical Informatics Conference, Cancun 2002. Lecture Notes
on Computer Science, 105-117, Berlin (2001).
[51] Gordon, D. M.: A Survey of Fast Exponentiation Methods. Journal of Algorithms, Vol. 27, 129-146,
(1998).
[52] Gorenstein, D., Lyons, R., Solomon, R.: The Classification of the Finite Simple Groups, Volume 40 of
Mathematical Surveys and Monogrpahs. AMS, Providence, (1998).
[53] Gruska, J.: Quantum Computing. MacGraw-Hill, (1999).
[54] Hahn, S.G., Lee, E., Park, J.H.: Complexity of the Generalized Conjugacy Problem. Discrete Applied
Mathematics, (2003).
[55] Hall, C., Goldberg, I., Schneider, B.: Reaction Attacks Against Several PublicKey Cryptosystems. Vijay
Varadharajan and Yi Mu, editors. Information and Communication Security, Second International
Conference, ICICS’99, Lecture Notes in Computer Science, pages 2-12. Springer, Vol. 1726, (1999).
[56] Hastad, J.: On using RSA with low exponent in a public key network. Advanced in Criptology-Proc. of
Crypto’85, LNCS, Vol. 218, 403-408, (1986).
[57] Hastad, J., Impagliazzo, R., Levin, L.A., Luby, M.: Pseudo random number generators from any one way
function. SIAM Journal on Computing, Vol. 28, 1364- 1396, (1999).
127 | P á g i n a
[58] Hastad, J.: Solving simultaneous modular equations of low degree. SIAM J. Comput., Vol. 17, 336-341,
(1988).
[59] Hastad, J., Naslund, M.: The securyty of individual RSA and discrete log bits.Journal of the AMS (2002).
[60] Hellman, M.E., Reyneri, J.M.: Fast computation of discrete logarithm in GF (p). Advances in Cryptology:
Proceedings of CRYPTO’82 Plenum Press, 3-13, (1983).
[61] Hoffman, K., Kunze, R.: Linear Algebra. Prentice-Hall, New Jersey (1971).
[62] Horng, G., Yang, C.S.: Key authentication scheme for cryptosystems based on discrete logarithms.
Computer Communications Vol. 19, 848-850, (1996).
[63] IEEE Std 1363.: IEEE Standard especifications for public key cryptography (2000).
[64] Kahn, D.: The Codebreakers, the Story of Secret Writing. Macmillan Publishing Co. Inc., (1967).
[65] Kitaev, A.Y., Shen, A.H., Vyalyi, M.N.: Classical and Quantum Computation. Graduate Studies in
Mathematics. AMS Press, Vol. 47, (2002).
[66] Ko, K.H., Lee, S.L., Cheon, J.H., Han, J.W., Kang, J., Park, C.: New PublicKey Cryptosystem using Braid
Groups. In Advances in Cryptology. Proceedings of CRYPTO 2000, Lecture Notes in Computer Science, pages
166-183, Santa Barbara, California, USA, (2000).
[67] Koblitz, N.: A Course in Number Theory and Cryptography, GTM 114, Springer Verlag, (1987).
[68] Koblitz, N.: Hyperelliptic Cryptosystems. Journal of Cryptology Vol. 1, (1989).
[69] Kraitchik, M.: Théorie des nombres. Gauthier-Villars. Vol. 1, 119-123, Paris (1922).
[70] Kurosawa, K., Takeuchi, M.: Public key cryptosystem using a reciprocal number with the same
intractability as factoring a large number. Cryptology, Vol. 1, 225-233, (1988).
[71] LaMacchia, B.A., Odlyzko, A.M.: Computation of discrete logarithm problem in prime fields. Designs,
Codes and Cryptography, Vol. 1, 46-62, (2001).
[72] Lee, C.C., Hwang, M.S., Li, L.H.: A new key authentication scheme based on discrete logarithms. Applied
Mathematics and Computation, 343-349, (2003).
[73] Lidl, R., Müller,W.B.: Permutation polynomials in RSA cryptosystems. Advances in Cryptology
Proceedings of Cryptology 83, 293-301, (1984).
[74] Lidl, R., Niederreiter, H.: Introduction to Finite Fields and Their Applications. Cambridge University
Press, (1994).
128 | P á g i n a
[75] Loxton, J.H., Khoo, D.S.P., Bird, G.J.: A cubic RSA code equivalent to factorization. Cryptology, Vol. 5,
139-150, (1992).
[76] Magliveras, S.S.: A cryptosystem from logarithmic signatures of finite groups. Proceedings of the 29’th
Midwest Symposium on Circuits and Systems, pages 972-975. Elsevier Publishing Company, (1986).
[77] McCurley, K.: The discret logarithm problem. Crytology and Computational Number Theory,
Proceedings of Symposia in Applied Mathematics, Vol. 42, 49-74, (1990).
[78] McEliece, R. J.: A Public Key Cryptosystem Based on Algebraic Coding Theory. DSN Progress Report 42-
44, Jet Propulsion Laboratory, (1978).
[79] McEliece, R. J.: Finite Fields for Computer Scientists and Engineers. Kluwer Academic Publishers, (1987).
[80] Menezes, A., Wu, Yi-Hong: A polinomial representation for logaritms in GF (q). Acta arithmetica, Vol. 47,
255-261, (1986).
[81] Menezes, A., Van Oorschot, P., Vanstone, S.: Handbook of Applied Cryptography. CRC Press, Florida
(2001).
[82] Menezes, A., Wu, Yi-Hong.: The Discrete Logarithm Problem in GL(n, q). Ars Combinatoria, Vol. 47, 22-
32, (1997).
[83] Miller, G.: Riemann’s hypothesis and test for primality. J. Comput. and Sistem Sci., Vol. 13, 300-317,
(1976).
[84] Miller, V. S.: Use of Elliptic Curves in Cryptography. Advances in Cryptology Crypto’85, Lecture Notes in
Computer Science, Vol. 218, (1985).
[85] Mollin, R.A..: RSA and public-key cryptography. Chapman and Hall /CRC Boca Raton. Florida (2003).
[86] Mosca, M., Ekert, A.: The Hidden Subgroup Problem and Eigenvalue Estimation on a Quantum
Computer. Proceedings of the 1st NASA International Conference on Quantum Computing and Quantum
Comunication, (1999).
[87] Mullen, G., White, D.: A polynomial representation for logarithms in GF(q). Acta Arithmetica, Vol. 47,
255-261, (1986).
[88] National Bureau of Standards. Data Encryption Standard, FIPS-Pub.46. National Bureau of Standards,
U.S. Department of Commerce. Washington D.C.,(1977).
[89] National Institute for Standards and Technology. Digital Signature Standard.Computer System
Laboratory, FIPS PUB 186, Gaithersburg, (1994).
129 | P á g i n a
[90] Niederreiter, H.: A short proof for explicit formulas for discrete logarithms infinite fields. Applicable
Algebra in Eng., Comm., and Computer, Vol. 1, 55-57, (1990).
[91] Odlyzko, A.M.: Discrete logarithm and smooth polynomils in finite fields. Theory, Applications and
Algorithms. G.L. Mullen and P. Shiue, eds., American Math. Society, Contemporary Math Series, 269-278,
(1994).
[92] Odoni, R. W. K., Varadharajan, V., Sanders, P. W.: Public Key Distribution in Matrix Rings. Electronic
Letters, Vol. 20, 386-387, (1984).
[93] Paeng, S.H., Kwon, D., Ha, K.C., Kim, J.H.: Improved public key cryptosystem using finite non-abelian
groups, IACR eprint (2001).
[94] Paeng, S.H., Ha, K.C., Kim, J.H., Chee, S., Park, C.: New Public Key Cryptosystem Using Finite Non Abelian
Groups. J. Kilian. Advances in cryptology - CRYPTO 2001, Lecture Notes in Computer Science, Springer, Vol.
2139, 470-485, (2001).
[95] Pocklington, H.C.: The determination of the prime or composite nature of large numbers by Fermat’s
theorem. Math. Porc. Cambridge Philos. Soc., Vol. 18, 29-30, (1914).
[96] Pohlig, S.C., Hellman, M.E.: An improved algorithm for computing logarithmsover GF (p) and its
cryptographic significance. IEEE Trans. Info. Theory, Vol. 24, 106-110, (1978).
[97] Pollard, J.M.: Monte Carlo methods for index computation (mod p). Math. Computation, Vol. 32, 918-
924, (1978).
[98] Popek, G., Kline, C.: Encryption and security computer networks. ACM Computing Survey, Vol. 11, 331-
356, (1979).
[99] Rabin, M.O.: Digitalized signartures and public key functions as intractable as factorization. MIT
Laboratory for Computer Science, Technical Report
MIT/LCS/TM-212, (1979).
[100] Rabin, M.O.: Probabilistic algorithms for testing primality. J. Number Theory,Vol. 12, 128-138, (1980).
[101] Reisel, H.: Mersenne numbers. MTAC, Vol. 12, 207-213, (1958).
[102] Riesel, H.: Prime numbers and computer methods for factorization. BirhäuserBoston (1994).
[103] Rivest, R., Shamir, A., Adleman, L.: A method for obtaining digital signaturesand public-key
cryptosystems. Communications of the ACM, Vol. 21, 120-126,
(1978).
130 | P á g i n a
[104] Rossen, K.: Elementary Number Theory International Edition. (2004).
[105] Rotman, J.J.: An Introduction to the Theory of Groups. Graduate Texts in Mathematics. Springer, Vol.
148, (1999).
[106] Salomaa, A.: Public Key Cryptology. Monographs on Theoretical Computer Science, Vol.23, Springer
Verlag, (1990).
[107] Scheidler, R., Buchmann, J.A., Williams, H.C.: A Key Exchange Protocol Using Real Quadratic Fields.
Journal of Cryptology, Vol. 7, 192-198, (1994).
[108] Scheidler, R., Williams, H.C.: A Public Key Cryptosystem Utilizing Cyclotomic Fields. Designs, Codes and
Cryptography, Vol. 6, 237-242, (1995).
[109] Schneier, B.: Applied Cryptography Second Edition: protocols, algorithms and source code in C. John
Wiley and Sons, New York (1996).
[110] Shanks, D.: Class number, a theory of factorization, and genera. Number Theory Institute, Proc.
Symposium pure Mathematics, American Mathematical Society, Vol. 20, 415-440, (1981).
[111] Shannon, C.: A Mathematical Theory of Communication. Bell System Thechnical Journal, (1948).
[112] Shannon, C.: Communications Theory of Secrecy Systems. Bell System Thechnical Journal, (1949).
[113] Short, P.W.: Algorithms for quantum computation: discrete logarithm and factoring. Proc. of the 35th
Annual IEEE Symposium on Foundations of Computer Science. IEEE Press, 124-134, (1994).
[114] Singh, S.: Los códigos secretos: El arte de la ciencia de la criptografía desde el antiguo Egipto a la era
de Internet, Debate. Madrid (2000).
[115] Solovay, R., Strassen, V.: A fast Monte-Carlo test for primality. SIAM J. Comput.,Vol. 6, 84-85, (1975).
[116] Sorenson, J.P.: Polylog depth circuits for integer factoring and discrete logarithms. Information and
Computation, Vol. 110, 1-18, (1994).
[117] Stallings, W.: Cryptography and Network Security: Principles and Practice. Third Edition. Prentice Hall,
New Jersey, (2003).
[118] Teske, E.: Squar-root algorithms for the discrete logarithm problem (a survey). Center for Applied
Cryptographic Research. University of Waterloo, Technical Report CORR 2001-07, (2001).
[119] Van Oorschot, P.: A comparison of practical public key cryptosystems based on integer factorization
and discrete logarithms. Contemporary Cryptology: The Science of information Integrity. IEEE Press, 289-
322, New York, (1992).
131 | P á g i n a
[120] Wells, A.L.: A polynomial form for logarithms modulo a prime. IEEE Trans. Information Theory, Vol. 30,
845-846, (1984).
[121] Wiener, M.J.: Cryptoanalysis of short RSA secret exponents. IEEE Trans.
[122] Williams, H.C.: A modification of RSA public key encryption procedure. IEEE Trans. Inform. Theory IEEE
Press,Vol. 26, 726-729, (1980).
132 | P á g i n a
133 | P á g i n a
Anexos
Resultados de las rondas del algoritmo AES al funcionar con
una matriz de ejemplo 57
57 Fundamentos de Critptográfia: apuntes. Universidad Nacional Autónoma de México
134 | P á g i n a
Modificaciones
A continuación se presenta una comparativa de las modificaciones hechas en los archivos de la
implementación del algoritmo AES. En el lado izquierdo se logra ver el archivo modificado, en el lado
derecho, el archivo de implementación original antes de mejoras.
Modificaciones: Archivo main.h
Modificaciones: aes.h
135 | P á g i n a
Modificaciones: main.c
136 | P á g i n a
137 | P á g i n a
138 | P á g i n a
139 | P á g i n a
140 | P á g i n a
141 | P á g i n a
Modificaciones: aes.c
142 | P á g i n a
143 | P á g i n a
144 | P á g i n a
145 | P á g i n a
146 | P á g i n a
147 | P á g i n a
148 | P á g i n a
149 | P á g i n a
150 | P á g i n a
Tablas S-Box58
58 FIPS PUB 197: the official AES standard. Federal Information Processing Standard. 2001-11-26. Retrieved 2010-04-29.
151 | P á g i n a
Código fuente de la implementación del algoritmo Aes.
Main.c
#include <LPC21xx.h>
#include "libreria_uart1.h"
#include "aes.h"
#include "main.h"
/* lista de interrupciones */
void IRQ_uart1_bloque(void) __irq;
void IRQ_uart1_clave(void) __irq;
/* variables*/
//parametros de cifrado
char cifrar = 1;
//Modo Cifrado (1) o Modo Descifrado (0)
int longitudClave = 128;
//longitud de la clave de cifrado (128,192 o 256)
unsigned char clave[32] =
{0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,
//Clave de cifrado/descifrado
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00};
//Si sobran posiciones seran ignoradas
//variables utiles
unsigned char claveRecibida[64];
//conjunto de caracteres que se reciben del teclado
//como clave ('1','A','6','2'...)
unsigned char palabraRecibida[32];
//conjunto de caracteres que se reciben del teclado
//para codificar('1','A','6','2'...)
unsigned char bloque[16];
//significado de esos caracteres (1A, 62...)
unsigned char palabraProcesada[16];
//palabra resultado del proceso de cifrado/descifrado
char numeroRondas;
char nuevaPalabra = 0;
/* funciones */
//deduce el significado de los caracteres ascii
//recibidos y lo introduce en la variable bloque
void fijaBloque(){
int i;
char caracter;
for(i=0;i<16;i++){
caracter = (leeCifra(palabraRecibida[2*i])<<4)
+leeCifra(palabraRecibida[(2*i)+1]);
bloque[i] = caracter;
}
}
//deduce el significado de los caracteres ascii
//recibidos y lo introduce en la variable clave
152 | P á g i n a
void fijaClave(){
int i;
char caracter;
for(i=0;i<longitudClave/8;i++){
caracter = (leeCifra(claveRecibida[2*i])<<4)
+leeCifra(claveRecibida[(2*i)+1]);
clave[i] = caracter;
}
}
//devuelve el valor numerico de un caracter ascii
unsigned char leeCifra(unsigned char caracter){
if (caracter >= '0' && caracter <= '9')
caracter = caracter - 48;
else
if (caracter >= 'A' && caracter <= 'F')
caracter = caracter - 55;
else
if (caracter >= 'a' && caracter <= 'f')
caracter = caracter - 87;
else
caracter = 0;
return caracter;
}
//devuelve la codificacion ascii de un valor numérico
unsigned char leeChar(unsigned char caracter){
if(caracter >= 0 && caracter <= 9)
caracter = caracter + 48;
else
if(caracter >= 10 && caracter <= 15)
caracter = caracter + 55;
else
caracter = 48;
return caracter;
}
//asigna a palabraRecibida el valor de nuevo[]
void setPalabraRecibida(unsigned char nuevo[]){
int i;
for(i=0;i<32;i++)
palabraRecibida[i] = nuevo[i];
nuevaPalabra = 1;
}
int main(){
//método main
char elemento, ronda;
unsigned char * puntero;
/* iniciliazaciones */
VPBDIV = 0x01; //Frecuencia de los perifericos
153 | P á g i n a
//(pclk) = 60MHz
iniUart1(); //inicializamos la uart1
/* VIC */
VICVectCntl1 = 0x00000027;
//asociamos el slot 1 al canal 7 (UART1)
VICVectAddr1 = (unsigned)IRQ_uart1_clave;
//direccion de la IRQ de recepcion de clave de 128 bits
//al VIC
/* Obtencion de parametros de cifrado */
//peticion y recepcion de cifrado/descifrado
enviarCadena_UART1("Pulse C si quiere cifrar o
D si quiere descifrar ");
//enviamos la cadena
while((U1LSR & 0x01) == 0x00);
//hasta que no recibamos un byte no pasa de aquí
numeroRondas = U1RBR;
//leemos el caracter recibido
if(numeroRondas == 'D' | numeroRondas == 'd'){
//si se ha recibido la letra D o d
enviarCadena_UART1("Proceso de descifrado ");
cifrar = 0;
//activamos el modo descifrado
}
else enviarCadena_UART1("Proceso de cifrado ");
//si hemos recibido cualquier otro caracter, se
//coloca modo cifrado
//peticion y recepcion del tamaño de clave
enviarSaltoDeCarro_UART1();
enviarCadena_UART1("Clave de cifrado: ");
enviarSaltoDeCarro_UART1();
enviarCadena_UART1("Si la longitud de la clave es
de 128 bits pulse 1, ");
enviarCadena_UART1("si es de 192 pulse 2 ");
enviarCadena_UART1("y si es de 256 pulse 3 ");
//enviamos la cadena
while((U1LSR & 0x01) == 0x00);
//hasta que no recibamos un byte no pasa de aquí
numeroRondas = U1RBR;
//leemos el caracter recibido
if(numeroRondas == '2'){
enviarCadena_UART1("Clave de 192 bits ");
longitudClave = 192;
}
else
if(numeroRondas == '3'){
enviarCadena_UART1("Clave de 256 bits ");
longitudClave = 256;
}
else
//si el caracter recibido no es '2' ni '3'
154 | P á g i n a
//entonces la clave es de 128 bits
enviarCadena_UART1("Clave de 128 bits ");
//peticion y recepcion de la clave de cifrado
VICIntEnable = 0x00000080;
//activamos la interrupcion de la UART1
enviarSaltoDeCarro_UART1();
enviarCadena_UART1("Introduzca la clave de cifrado ");
while(nuevaPalabra == 0);
//hasta que no haya llegado la clave no pasa de aqui
VICIntEnClr = 0x00000080;
//desactivamos la interrupcion de la UART1
nuevaPalabra = 0;
VICVectAddr1 = (unsigned)IRQ_uart1_bloque;
//direccion de la IRQ de recepcion de bloque al VIC
//a partir de aquí solamente usaremos la interrupcion
//de bloque recibido
enviarCadena_UART1("Clave recibida");
enviarSaltoDeCarro_UART1();
//calculamos el numero de rondas en funcion
//del tamaño de la clave
numeroRondas = longitudClave/32 + 6;
fijaClave();
/* Creamos las subclaves */
keyExpansion();
//se calculan todas las subclaves
enviarCadena_UART1("Envie el texto a cifrar en
bloques de 16 bytes");
enviarSaltoDeCarro_UART1();
while(1){ //bucle de funcionamiento
/* espera de la palabra */
VICIntEnable = 0x00000080;
//activamos la interrupcion de la UART1
while(nuevaPalabra == 0);
//hasta que no haya llegado una nueva palabra
//no pasa de aqui
VICIntEnClr = 0x00000080;
//desactivamos la interrupcion de la UART1
nuevaPalabra = 0;
/* si salimos del while, quiere decir que
el bloque está completo y debe ser dado a AES */
fijaBloque();
//fijamos el bloque a codificar(valores numéricos) a
//partir del valor almacenado en palabraRecibida(
//codificacion ascii)
setEstado(bloque);
//entregamos el bloque a aes.c
155 | P á g i n a
if(cifrar == 1){
//Si tenemos que cifrar
/* comienza AES en modo cifrado */
// **Ronda inicial**
addRoundKey(0);
// **Rondas principales**
for(ronda=1;ronda<numeroRondas;ronda++){
subBytes();
shiftRows();
mixColumns();
addRoundKey(ronda);
}
// **Ronda final**
//es igual que las principales pero
//sin el mixColums
subBytes();
shiftRows();
addRoundKey(numeroRondas); //el último
//addRoundKey no lo medimos, puesto que detrás no
//viene la SBox
}
else{ //Si no, tenemos que descifrar...
/* comienza AES en modo descifrado */
// **Ronda inicial**
addRoundKey(numeroRondas);
// **Rondas principales**
for(ronda=numeroRondas - 1;ronda>0;ronda--){
invShiftRows();
invSubBytes();
addRoundKey(ronda);
IOCLR0 = 0x00200000;
//avisamos al osciloscopio (poniendo un pin a 0)
//para que deje de medir
invMixColumns();
}
// **Ronda final**
//es igual que las principales pero sin el
//mixColums
invShiftRows();
invSubBytes();
addRoundKey(0);
}
/* AES finalizado, extraemos los
datos cifrados */
puntero = (unsigned char*)getEstado();
for(elemento=0;elemento<4;elemento++)
for(ronda=0;ronda<4;ronda++)
palabraProcesada[((3-(ronda))*4)+elemento]
= *puntero++;
156 | P á g i n a
/* y los devolvemos por la UART1 */
//ponemos un salto de carro para separar
//lo enviado de lo recibido
while((U1LSR | 0xDF) == 0xDF);
//hasta que no esté vacio por completo
//no pasa de aquí
U1THR = '\r';
U1THR = '\n';
while((U1LSR | 0xDF) == 0xDF);
//hasta que no esté vacio por completo
//no pasa de aquí
for(elemento=0;elemento<8;elemento++){
U1THR = leeChar(palabraProcesada[elemento]
/16);
U1THR = leeChar(palabraProcesada[elemento]
%16);
}
while((U1LSR | 0xDF) == 0xDF);
//hasta no esté vacio por completo
//no pasa de aquí
for(elemento=8;elemento<16;elemento++){
U1THR = leeChar(palabraProcesada[elemento]/16);
U1THR = leeChar(palabraProcesada[elemento]%16);
}
//cadena puesta, ahora ponemos el salto
//de carro
while((U1LSR | 0xDF) == 0xDF);
//hasta que no esté vacio por completo no
//pasa de aquí
U1THR = '\r';
U1THR = '\n';
}
}
157 | P á g i n a
Aes.c
/*
******************************************************************
Para hacer que trabaje a 32 bits en vez de a 8 bits bastara con
modificar las funciones del archivo aes.c para que trabaje a 32 bits
******************************************************************
*/
#include <LPC21xx.h>
#include "main.h"
extern char numeroRondas;
extern unsigned char clave[32];
//tabla de la SBOX
int sbox[256] = { //0 1 2 3 4 5 6 7 8 9 A B C D E F
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
//0
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
//1
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
//2
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
//3
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
//4
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
//5
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
//6
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
//7
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
//8
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
//9
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
//A
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
//B
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
//C
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
//D
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
//E
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
}; //F
// tabla inversa de la SBOX
int isbox[256] = { //0 1 2 3 4 5 6 7
8 9 A B C D E F
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
//0
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
//1
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
//2
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
//3
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
//4
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
//5
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
//6
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
//7
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
//8
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
//9
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
//A
158 | P á g i n a
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
//B
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
//C
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
//D
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
//E
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
}; //F
//matriz que almacena las columnas de la matriz de estado
unsigned int estado[4];
//array que almacena las claves intermedias (round keys)
unsigned int TRoundKey[60];
//clave de la codificacion
unsigned int Key[4];
// Rcon[i] contiene las constantes fruto de elevar x a la potencia
enesima de (i-1) siendo
// potencias de x (x denotado como {02}) en el campo GF(28)
// Hay que tener en cuenta que i comienza en 1 y no en 0
int Rcon[12] = {0x8d000000, 0x01000000, 0x02000000, 0x04000000,
0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000,
0x36000000, 0x6c000000};
//fija el bloque a codificar (Las cuatro columnas)
//se posicionan trasponiendo la matriz
void setEstado(unsigned char entrada[16]){
char i;
for(i=0;i<4;i++)
estado[i] =
(entrada[i] << 24) ^
(entrada[i + 4] << 16) ^
(entrada[i + 8] << 8) ^
entrada[i + 12];
}
//devuelve el bloque de codificacion en un puntero a un array de 4 int
unsigned int* getEstado(){
return estado;
}
//esta funcion produce las Nb(Nr+1) subclaves (round keys) que se usan en
cada ronda de encriptado
void keyExpansion(){
char i, end;
// Las primeras posiciones del vector de subclaves son ocupadas por
la clave principal
for(i=0;i<4;i++)
TRoundKey[i] =
(clave[i] << 24) ^
(clave[i + 4] << 16) ^
(clave[i + 8] << 8) ^
clave[i + 12];
159 | P á g i n a
// En funcion del tamaño de la clave, esta funcion sera de una manera o de otra
if(numeroRondas == 10){ //Si es de 128 bits
while(i < 44){ // mientras que sigue rellenando subclaves... (11 subclaves de
4 palabras cada una)
//1
TRoundKey[i] = TRoundKey[i-4] ^
//palabra de la subclave anterior
((sbox[TRoundKey[i-3] & 0x000000FF]) <<
24) ^ //Sbox del elemento 13 de la subclave anterior movido 24 bits a la izquierda
(Rcon[i/4]);
//rcon del número de la columna
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//2
TRoundKey[i] = TRoundKey[i-4] ^
((sbox[TRoundKey[i-3] & 0x000000FF]) <<
24); //Sbox del elemento 14 de la subclave anterior movido 24 bits a la izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//3
TRoundKey[i] = TRoundKey[i-4] ^
((sbox[TRoundKey[i-3] & 0x000000FF]) <<
24); //Sbox del elemento 15 de la subclave anterior movido 24 bits a la izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//4
TRoundKey[i] = TRoundKey[i-4] ^
((sbox[TRoundKey[i-7] & 0x000000FF]) <<
24); //Sbox del elemento 12 de la subclave anterior movido 24 bits a la izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
}//Fin while
}//Fin if 128
else{
if(numeroRondas == 12){ //Si la clave es de 192 bits...
//Colocamos lo que nos queda de la clave principal en las dos
primeras columnas
for(;i<8;i++)
TRoundKey[i] = (clave[i + 12] << 24) ^ (clave[i + 16] << 16);
//Rellenamos las siguientes dos columnas para acabar con el grupo de
4 subclaves
TRoundKey[4] ^= (TRoundKey[0]>>16) ^
//Sumamos lo de 6 columnas atras
((sbox[(TRoundKey[5]>>16) &
0x000000FF]) << 8) ^ //SBox del elemento 21 de la subclave actual movido 8 bits a la
izquierda
(Rcon[1] >> 16);
//Rcon del número de la columna
TRoundKey[4] ^= (TRoundKey[4] & 0x0000FF00) >> 8;
//Arrastramos sumando la ronda anterior
TRoundKey[5] ^= (TRoundKey[1]>>16) ^
((sbox[(TRoundKey[6]>>16) &
0x000000FF]) << 8); //SBox del elemento 22 de la subclave actual movido 8 bits a
la izquierda
TRoundKey[5] ^= (TRoundKey[5] & 0x0000FF00) >> 8;
//Arrastramos sumando la ronda anterior
TRoundKey[6] ^= (TRoundKey[2]>>16) ^
((sbox[(TRoundKey[7]>>16) &
0x000000FF]) << 8); //SBox del elemento 23 de la subclave actual movido 8 bits a
la izquierda
TRoundKey[6] ^= (TRoundKey[6] & 0x0000FF00) >> 8;
//Arrastramos sumando la ronda anterior
160 | P á g i n a
TRoundKey[7] ^= (TRoundKey[3]>>16) ^
((sbox[(TRoundKey[4]>>16) &
0x000000FF]) << 8); //SBox del elemento 20 de la subclave actual movido 8 bits a
la izquierda
TRoundKey[7] ^= (TRoundKey[7] & 0x0000FF00) >> 8;
//Arrastramos sumando la ronda anterior
while(i < 48){ //Bucle de relleno de subclaves
//Hay tres tipos de bloques:
//Primer bloque (No contiene rot+Sbox)
//0 - 3
for(end=i+4;i<end;i++){
TRoundKey[i] = (TRoundKey[i-8] << 16) ^ (TRoundKey[i-
4] >> 16) ^ //Sumamos lo de 6 columnas atras
(TRoundKey[i-4] <<24);
//Y lo de la ultima columna de las
anteriores a la primera de las nuevas
TRoundKey[i] ^= (TRoundKey[i]>>8) ^ (TRoundKey[i]>>16)
^ (TRoundKey[i]>>24); //Arrastramos sumando la ronda anterior
}
//Segundo bloque (Contiene rot+Sbox en la primera columna)
//4
TRoundKey[i] = (TRoundKey[i-8]<<16) ^ (TRoundKey[i-4]>>16) ^
//Sumamos lo de 6 columnas atras
((sbox[TRoundKey[i-3] &
0x000000FF]) << 24) ^ //Sbox del elemento 13 de la subclave anterior movido 24 bits a la
izquierda
(Rcon[i/6]);
//Rcon del número de la columna
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24); //Arrastramos sumando la ronda anterior
i++;
//5
TRoundKey[i] = (TRoundKey[i-8]<<16) ^ (TRoundKey[i-4]>>16) ^
((sbox[TRoundKey[i-3] &
0x000000FF]) << 24); //Sbox del elemento 14 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//6
TRoundKey[i] = (TRoundKey[i-8]<<16) ^ (TRoundKey[i-4]>>16) ^
((sbox[TRoundKey[i-3] &
0x000000FF]) << 24); //Sbox del elemento 15 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//7
TRoundKey[i] = (TRoundKey[i-8]<<16) ^ (TRoundKey[i-4]>>16) ^
((sbox[TRoundKey[i-7] &
0x000000FF]) << 24); //Sbox del elemento 12 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//Tercer bloque (Contiene rot+Sbox en la tercera columna)
//Primero nos ocupamos del fin de las seis columnas
anteriores
//8 - 11
for(end=i+4;i<end;i++){
TRoundKey[i] = (TRoundKey[i-8] << 16) ^
//Sumamos lo de 6 columnas atras
(TRoundKey[i-4] << 24);
//y la ultima columna
TRoundKey[i] ^= (TRoundKey[i] & 0xFF000000) >> 8;
//Arrastramos sumando la anterior columna
}
161 | P á g i n a
i = i-4;
//Y después del inicio de las 6 columnas siguientes
//8
TRoundKey[i] ^= (TRoundKey[i-4]>>16) ^
//Sumamos lo de 6 columnas atras
((sbox[(TRoundKey[i+1]>>16) &
0x000000FF]) << 8) ^ //SBox del elemento 21 de la subclave actual movido 8 bits a la
izquierda
(Rcon[(i+2)/6]>>16);
//Rcon del número de la columna
TRoundKey[i] ^= (TRoundKey[i] & 0x0000FF00) >> 8;
//Arrastramos sumando la ronda anterior
i++;
//9
TRoundKey[i] ^= (TRoundKey[i-4]>>16) ^
((sbox[(TRoundKey[i+1]>>16) &
0x000000FF]) << 8); //SBox del elemento 22 del grupo de claves actual movido 8 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] & 0x0000FF00) >> 8;
i++;
//10
TRoundKey[i] ^= (TRoundKey[i-4]>>16) ^
((sbox[(TRoundKey[i+1]>>16) &
0x000000FF]) << 8); //SBox del elemento 23 de la subclave actual movido 8 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] & 0x0000FF00) >> 8;
i++;
//11
TRoundKey[i] ^= (TRoundKey[i-4]>>16) ^
((sbox[(TRoundKey[i-3]>>16) &
0x000000FF]) << 8); //SBox del elemento 20 de la subclave actual movido 8 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] & 0x0000FF00) >> 8;
i++;
} //Fin while funcionamiento
//Pero todavia quedan 4 filas sin colocar
//0 - 3
for(;i<52;i++){
TRoundKey[i] = (TRoundKey[i-8] << 16) ^ (TRoundKey[i-4] >> 16)
^ //Sumamos lo de 6 columnas atras
(TRoundKey[i-4] <<24);
//Y lo de la ultima columna de las anteriores a
la primera de las nuevas
TRoundKey[i] ^= (TRoundKey[i]>>8) ^ (TRoundKey[i]>>16) ^
(TRoundKey[i]>>24); //Arrastramos sumando la ronda anterior
}
//Todas las subclaves creadas y traspuestas
}//Fin if 192
else{ //Si la clave es de 256 bits...
for(;i<8;i++)
TRoundKey[i] = 0x00 ^
(clave[i + 12] << 24) ^
(clave[i + 16] << 16) ^
(clave[i + 20] << 8) ^
clave[i + 24];
while(i < 56){ // mientras que sigue rellenando subclaves... (15
subclaves de 4 palabras cada una)
//Dos subclaves por paso:
//Primera subclave
//0
TRoundKey[i] = TRoundKey[i-8] ^
//palabra de la subclave anterior
((sbox[TRoundKey[i-3] &
0x000000FF]) << 24) ^ //Sbox del elemento 13 de la subclave anterior movido 24 bits a la
izquierda
162 | P á g i n a
(Rcon[i/8]);
//rcon del número de la columna
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//1
TRoundKey[i] = TRoundKey[i-8] ^
((sbox[TRoundKey[i-3] &
0x000000FF]) << 24); //Sbox del elemento 14 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//2
TRoundKey[i] = TRoundKey[i-8] ^
((sbox[TRoundKey[i-3] &
0x000000FF]) << 24); //Sbox del elemento 15 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//3
TRoundKey[i] = TRoundKey[i-8] ^
((sbox[TRoundKey[i-7] &
0x000000FF]) << 24); //Sbox del elemento 12 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >> 16) ^
(TRoundKey[i] >> 24);
i++;
//Segunda subclave
//4 - 7
for(end=i+4;i<end;i++){
TRoundKey[i] = TRoundKey[i-8] ^
//palabra de la subclave anterior
((sbox[TRoundKey[i-4] &
0x000000FF]) << 24); //Sbox del elemento 14 de la subclave anterior movido 24 bits a la
izquierda
TRoundKey[i] ^= (TRoundKey[i] >> 8) ^ (TRoundKey[i] >>
16) ^ (TRoundKey[i] >> 24);
}
}//Fin while
//Pero todavia quedan 4 filas sin colocar
//56
TRoundKey[56] = TRoundKey[48] ^
//palabra de la subclave anterior
((sbox[TRoundKey[53] & 0x000000FF]) <<
24) ^ //Sbox del elemento 13 de la subclave anterior movido 24 bits a la izquierda
(Rcon[7]);
//rcon del número de la columna
TRoundKey[56] ^= (TRoundKey[56] >> 8) ^ (TRoundKey[56] >> 16) ^
(TRoundKey[56] >> 24);
//57
TRoundKey[57] = TRoundKey[49] ^
((sbox[TRoundKey[54] & 0x000000FF]) <<
24); //Sbox del elemento 14 de la subclave anterior movido 24 bits a la izquierda
TRoundKey[57] ^= (TRoundKey[57] >> 8) ^ (TRoundKey[57] >> 16) ^
(TRoundKey[57] >> 24);
//58
TRoundKey[58] = TRoundKey[50] ^
((sbox[TRoundKey[55] & 0x000000FF]) <<
24); //Sbox del elemento 15 de la subclave anterior movido 24 bits a la izquierda
TRoundKey[58] ^= (TRoundKey[58] >> 8) ^ (TRoundKey[58] >> 16) ^
(TRoundKey[58] >> 24);
//59
TRoundKey[59] = TRoundKey[51] ^
((sbox[TRoundKey[52] & 0x000000FF]) <<
163 | P á g i n a
24); //Sbox del elemento 12 de la subclave anterior movido 24 bits a la izquierda
TRoundKey[59] ^= (TRoundKey[59] >> 8) ^ (TRoundKey[59] >> 16) ^
(TRoundKey[59] >> 24);
}//Fin if 256
}
/*
//HABRIA QUE TRASPONER ESTA SOLUCION
char i;
char palabrasClave;
unsigned int auxiliar;
unsigned int aux[4];
if(numeroRondas == 14) //Si la clave es de 256bits
palabrasClave = 8; //ocupa 8 palabras de 32 bits
else
if(numeroRondas == 12) //Si es de 192
palabrasClave = 6; //ocupa 6
else
palabrasClave = 4; //Si es de 128 ocupa 4
// La clave principal ocupa las primeras posiciones dentro del vector de subclaves
for(i=0;i<palabrasClave;i++)
TRoundKey[i] = 0x00 ^
(clave[i*4] << 24) ^
(clave[i*4 + 1] << 16) ^
(clave[i*4 + 2] << 8) ^
clave[i*4 + 3];
//Si la clave no es de 256bits...
if (numeroRondas != 14){
// mientras que sigue rellenando subclaves...
while(i < 4*(numeroRondas+1)){
auxiliar = TRoundKey[i-1];
if(i % palabrasClave == 0){ //cada palabrasClave rondas...
//RotByte
auxiliar = (auxiliar << 8) ^ (auxiliar >> 24);
//SubBytes
auxiliar = (sbox[auxiliar & 0x000000FF]) ^
(sbox[(auxiliar & 0x0000FF00)>>8]<<8) ^
(sbox[(auxiliar & 0x00FF0000)>>16]<<16) ^
(sbox[(auxiliar & 0xFF000000)>>24]<<24); //Los
desplazamos a un lado y al otro para acceder a la tabla sbox y después colocar los bytes en
su sitio
auxiliar ^= (Rcon[i/4]<<24);
}
TRoundKey[i] = TRoundKey[i - palabrasClave] ^ auxiliar;
i++;
}
}
//Si la clave es de 256 bits...
else{
// mientras que sigue rellenando subclaves...
while(i < 4*(numeroRondas+1)){
auxiliar = TRoundKey[i-1];
if(i % palabrasClave == 0){ //cada palabrasClave rondas...
//RotByte
auxiliar = (auxiliar << 8) ^ (auxiliar >> 24);
//SubBytes
auxiliar = (sbox[auxiliar & 0x000000FF]) ^
(sbox[(auxiliar & 0x0000FF00)>>8]<<8) ^
(sbox[(auxiliar & 0x00FF0000)>>16]<<16) ^
(sbox[(auxiliar & 0xFF000000)>>24]<<24); //Los
desplazamos a un lado y al otro para acceder a la tabla sbox y después colocar los bytes en
su sitio
auxiliar ^= (Rcon[i/4]<<24);
}
else if (i % palabrasClave == 4)
auxiliar = (sbox[auxiliar & 0x000000FF]) ^
(sbox[(auxiliar & 0x0000FF00)>>8]<<8) ^
(sbox[(auxiliar & 0x00FF0000)>>16]<<16) ^
(sbox[(auxiliar & 0xFF000000)>>24]<<24); //Los
desplazamos a un lado y al otro para acceder a la tabla sbox y después colocar los bytes en
su sitio
164 | P á g i n a
TRoundKey[i] = TRoundKey[i - palabrasClave] ^ auxiliar;
i++;
}
}
//Trasponemos la solución
for(i=0;i<numeroRondas+1;i++){
aux[0] = TRoundKey[4*i] & 0xFF000000 ^
((TRoundKey[4*i+1] & 0xFF000000) >> 8) ^
((TRoundKey[4*i+2] & 0xFF000000) >> 16) ^
(TRoundKey[4*i+3] >> 24);
aux[1] = ((TRoundKey[4*i] & 0x00FF0000) << 8) ^
(TRoundKey[4*i+1] & 0x00FF0000) ^
((TRoundKey[4*i+2] & 0x00FF0000) >> 8) ^
((TRoundKey[4*i+3] & 0x00FF0000) >> 16);
aux[2] = ((TRoundKey[4*i] & 0x0000FF00) << 16) ^
((TRoundKey[4*i+1] & 0x0000FF00) << 8) ^
(TRoundKey[4*i+2] & 0x0000FF00) ^
((TRoundKey[4*i+3] & 0x0000FF00) >> 8);
aux[3] = (TRoundKey[4*i] << 24) ^
((TRoundKey[4*i+1] & 0x000000FF) << 16) ^
((TRoundKey[4*i+2] & 0x000000FF) << 8) ^
(TRoundKey[4*i+3] & 0x000000FF);
TRoundKey[4*i] = aux[0];
TRoundKey[4*i+1] = aux[1];
TRoundKey[4*i+2] = aux[2];
TRoundKey[4*i+3] = aux[3];
}*/
}
// Suma la subclave de ronda al estado con una operación XOR
void addRoundKey(char round){
estado[0] ^= TRoundKey[4*round];
estado[1] ^= TRoundKey[4*round+1];
estado[2] ^= TRoundKey[4*round+2];
estado[3] ^= TRoundKey[4*round+3];
/*
char i;
for (i=0;i<4;i++)
estado[i] ^= TRoundKey[(4*round)+i];
*/
}
// La funcion SubBytes sistutuye, a nivel de bytes, los valores del
vector de estado con valores de la S-box
void subBytes(){
estado[0] = (sbox[estado[0] & 0x000000FF]) ^
(sbox[(estado[0] & 0x0000FF00)>>8]<<8) ^
(sbox[(estado[0] & 0x00FF0000)>>16]<<16) ^
(sbox[(estado[0] >> 24)]<<24);
estado[1] = (sbox[estado[1] & 0x000000FF]) ^
(sbox[(estado[1] & 0x0000FF00)>>8]<<8) ^
(sbox[(estado[1] & 0x00FF0000)>>16]<<16) ^
(sbox[(estado[1] >> 24)]<<24);
estado[2] = (sbox[estado[2] & 0x000000FF]) ^
(sbox[(estado[2] & 0x0000FF00)>>8]<<8) ^
(sbox[(estado[2] & 0x00FF0000)>>16]<<16) ^
(sbox[(estado[2] >> 24)]<<24);
165 | P á g i n a
estado[3] = (sbox[estado[3] & 0x000000FF]) ^
(sbox[(estado[3] & 0x0000FF00)>>8]<<8) ^
(sbox[(estado[3] & 0x00FF0000)>>16]<<16) ^
(sbox[(estado[3] >> 24)]<<24);
/*
char i;
for(i=0;i<4;i++){
estado[i] = (sbox[estado[i] & 0x000000FF]) ^
(sbox[(estado[i] & 0x0000FF00)>>8]<<8) ^
(sbox[(estado[i] & 0x00FF0000)>>16]<<16) ^
(sbox[(estado[i] & 0xFF000000)>>24]<<24); //Los
desplazamos a un lado y al otro para acceder a la tabla sbox y después
colocar los bytes en su sitio
}
*/
}
// La funcion InvSubBytes sistutuye, a nivel de bytes, los valores del
vector de estado con valores de la Inv S-box
void invSubBytes(){
estado[0] = (isbox[estado[0] & 0x000000FF]) ^
(isbox[(estado[0] & 0x0000FF00)>>8]<<8) ^
(isbox[(estado[0] & 0x00FF0000)>>16]<<16) ^
(isbox[(estado[0] >> 24)]<<24);
estado[1] = (isbox[estado[1] & 0x000000FF]) ^
(isbox[(estado[1] & 0x0000FF00)>>8]<<8) ^
(isbox[(estado[1] & 0x00FF0000)>>16]<<16) ^
(isbox[(estado[1] >> 24)]<<24);
estado[2] = (isbox[estado[2] & 0x000000FF]) ^
(isbox[(estado[2] & 0x0000FF00)>>8]<<8) ^
(isbox[(estado[2] & 0x00FF0000)>>16]<<16) ^
(isbox[(estado[2] >> 24)]<<24);
estado[3] = (isbox[estado[3] & 0x000000FF]) ^
(isbox[(estado[3] & 0x0000FF00)>>8]<<8) ^
(isbox[(estado[3] & 0x00FF0000)>>16]<<16) ^
(isbox[(estado[3] >> 24)]<<24);
/*
char i;
for(i=0;i<4;i++){
estado[i] = (isbox[estado[i] & 0x000000FF]) ^
(isbox[(estado[i] & 0x0000FF00)>>8]<<8) ^
(isbox[(estado[i] & 0x00FF0000)>>16]<<16) ^
(isbox[(estado[i] & 0xFF000000)>>24]<<24);
//Los desplazamos a un lado y al otro para acceder a la tabla isbox
y después colocar los bytes en su sitio
}
*/
}
// La funcion ShiftRows rota cada columna un número distinto de bytes
// Se rota tantos bytes como índice tiene la columna
void shiftRows(){
//la primera columna se queda igual
//la segunda columna rota un byte
166 | P á g i n a
estado[1] = (estado[1] >> 24) ^ (estado[1] << 8);
//la tercera columna rota 2 bytes
estado[2] = (estado[2] >> 16) ^ (estado[2] << 16);
//la cuarta columna rota 3 bytes
estado[3] = (estado[3] >> 8) ^ (estado[3] << 24);
/*
unsigned int aux;
// la primera columna se queda igual
// La segunda columna rota un byte
aux = estado[1] >> 24; //ponemos en su futura posicion al primer
byte, añadiendo ceros por la izquierda
estado[1] <<= 8; //desplazamos un byte la columna
estado[1] ^= aux; //le añadimos el primer byte
// La segunda columna rota dos bytes
aux = estado[2] >> 16; //ponemos en su futura posicion los dos
primeros bytes, añadiendo ceros por la izquierda
estado[2] <<= 16; //desplazamos dos bytes la columna
estado[2] ^= aux; //le añadimos los dos primeros bytes
// La tercera columna rota tres bytes
aux = estado[3] >> 8; //ponemos en su futura posicion los tres
primeros bytes, añadiendo ceros por la izquierda
estado[3] <<= 24; //desplazamos tres bytes la columna
estado[3] ^= aux; //le añadimos el primer byte
*/
}
// La funcion InvShiftRows rota cada columna un número distinto de bytes
// Se rota tantos bytes como índice tiene la columna
void invShiftRows(){
//la primera columna se queda igual
//la segunda columna rota un byte
estado[1] = (estado[1] << 24) ^ (estado[1] >> 8);
//la tercera columna rota 2 bytes
estado[2] = (estado[2] << 16) ^ (estado[2] >> 16);
//la cuarta columna rota 3 bytes
estado[3] = (estado[3] << 8) ^ (estado[3] >> 24);
/*
unsigned int aux;
// la primera columna se queda igual
// La segunda columna rota un byte
aux = estado[1] << 24; //ponemos en su futura posicion al primer
byte, añadiendo ceros por la izquierda
estado[1] >>= 8; //desplazamos un byte la columna
estado[1] ^= aux; //le añadimos el primer byte
// La segunda columna rota dos bytes
aux = estado[2] << 16; //ponemos en su futura posicion los dos
167 | P á g i n a
primeros bytes, añadiendo ceros por la izquierda
estado[2] >>= 16; //desplazamos dos bytes la columna
estado[2] ^= aux; //le añadimos los dos primeros bytes
// La tercera columna rota tres bytes
aux = estado[3] << 8; //ponemos en su futura posicion los tres
primeros bytes, añadiendo ceros por la izquierda
estado[3] >>= 24; //desplazamos tres bytes la columna
estado[3] ^= aux; //le añadimos el primer byte
*/
}
// xtime es un macro que devuelve el producto con modulo {1b} de {02} y
la palabra argumento
// aunque la operacion sea de 32 bits, el producto es byte a byte
#define xtime(x) (((x & 0x7F7F7F7F) << 1) ^ (((x>>7) & 0x01010101) *
0x1b))
//xtime a 8 bits
//#define xtime(x) ((x<<1) ^ (((x>>7) & 1) * 0x1b))
// Multiply es un macro que multiplica numeros en el gampo GF(2^8)
//Multiply a 32 bits
//#define Multiply(x,y) (((y & 0x01010101) * x) ^ ((y>>1 & 0x01010101) *
xtime(x)) ^ ((y>>2 & 0x01010101) * xtime(xtime(x))) ^ ((y>>3 &
0x01010101) * xtime(xtime(xtime(x)))) ^ ((y>>4 & 0x01010101) *
xtime(xtime(xtime(xtime(x))))))
//Multiply a 8 bits
//#define Multiply(x,y) (((y & 1) * x) ^ ((y>>1 & 1) * xtime(x)) ^ ((y>>2
& 1) * xtime(xtime(x))) ^ ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^ ((y>>4
& 1) * xtime(xtime(xtime(xtime(x))))))
// La funcion MixColumns mezcla las columnas siguiendo los pasos de G.
Bertoni
void mixColumns(){
//CON TODAS LAS MEJORAS
unsigned int salida[4];
// primer paso
salida[0] = estado[1] ^ estado[2] ^ estado[3];
salida[1] = estado[0] ^ estado[2] ^ estado[3];
salida[2] = estado[0] ^ estado[1] ^ estado[3];
salida[3] = estado[0] ^ estado[1] ^ estado[2];
// segundo paso, multiplicación por dos en el campo de galois
estado[0] = xtime(estado[0]);
estado[1] = xtime(estado[1]);
estado[2] = xtime(estado[2]);
estado[3] = xtime(estado[3]);
//tercer paso
salida[0] ^= estado[0] ^ estado[1];
estado[1] ^= salida[1] ^ estado[2];
estado[2] ^= salida[2] ^ estado[3];
estado[3] ^= salida[3] ^ estado[0];
estado[0] = salida[0];
168 | P á g i n a
/*
//SOLO MEJORA 32BITS
unsigned int salida[4];
unsigned int i;
// primer paso
for(i=0;i<4;i++)
salida[i] = estado[(i+1)%4] ^ estado[(i+2)%4] ^
estado[(i+3)%4];
// segundo paso, multiplicación por dos en el campo de galois
for(i=0;i<4;i++)
estado[i] = xtime(estado[i]&0x000000FF)
^ ((xtime((estado[i]>>8)&0x000000FF))<<8)
^ ((xtime((estado[i]>>16)&0x000000FF))<<16)
^ ((xtime(estado[i]>>24))<<24);
//tercer paso
for(i=0;i<4;i++)
salida[i] ^= estado[i] ^ estado[(i+1)%4];
for(i=0;i<4;i++)
estado[i] = salida[i];
*/
/*
//MEJORA 32BITS + MEJORA XTIME
unsigned int salida[4];
unsigned int i;
// primer paso
for(i=0;i<4;i++)
salida[i] = estado[(i+1)%4] ^ estado[(i+2)%4] ^
estado[(i+3)%4];
// segundo paso, multiplicación por dos en el campo de galois
for(i=0;i<4;i++)
estado[i] = xtime(estado[i]);
//tercer paso
for(i=0;i<4;i++)
salida[i] ^= estado[i] ^ estado[(i+1)%4];
for(i=0;i<4;i++)
estado[i] = salida[i];
*/
}
// La funcion InvMixColumns mezcla las columnas de una manera más
eficiente
void invMixColumns(){
//CON TODAS LAS MEJORAS
unsigned int salida[4];
// tenemos que hacer la matriz
// 14 11 13 9
// 9 14 11 13
// 13 9 14 11
// 11 13 9 14
//
169 | P á g i n a
// pero la podemos dividir en [1] + [2]:
//
// 2 3 1 1 12 8 12 8
// 1 2 3 1 + 8 12 8 12
// 1 1 2 3 12 8 12 8
// 3 1 1 2 8 12 8 12
// primero calculamos [1], que es igual que en el cypher
// primer paso
salida[0] = estado[1] ^ estado[2] ^ estado[3];
salida[1] = estado[0] ^ estado[2] ^ estado[3];
salida[2] = estado[0] ^ estado[1] ^ estado[3];
salida[3] = estado[0] ^ estado[1] ^ estado[2];
// segundo paso, multiplicación por dos en el campo de galois
estado[0] = xtime(estado[0]);
estado[1] = xtime(estado[1]);
estado[2] = xtime(estado[2]);
estado[3] = xtime(estado[3]);
// tercer paso
salida[0] ^= estado[0] ^ estado[1];
salida[1] ^= estado[1] ^ estado[2];
salida[2] ^= estado[2] ^ estado[3];
salida[3] ^= estado[3] ^ estado[0];
// y después le sumamos [2]
//cuarto paso, suma y doblado en el campo de galois
estado[0] = xtime((estado[0] ^ estado[2])); //4(x0+x2)
estado[1] = xtime((estado[1] ^ estado[3])); //4(x1+x3)
estado[2] = xtime((estado[0] ^ estado[1]));
//8(x0+x1+x2+x3)
//quinto paso
salida[1] ^= estado[2] ^ estado[1];
salida[2] ^= estado[2] ^ estado[0];
estado[0] ^= estado[2] ^ salida[0];
estado[3] = salida[3] ^ estado[2] ^ estado[1];
estado[1] = salida[1];
estado[2] = salida[2];
/*
//MEJORA 32BITS + MEJORA XTIME + MEJORA CALCULOS
unsigned int salida[4];
unsigned int i;
for(i=0;i<4;i++)
salida[i] = estado[(i+1)%4] ^ estado[(i+2)%4] ^
estado[(i+3)%4];
for(i=0;i<4;i++)
estado[i] = xtime(estado[i]);
for(i=0;i<4;i++)
salida[i] ^= estado[i] ^ estado[(i+1)%4];
170 | P á g i n a
estado[0] = xtime((estado[0] ^ estado[2]));
//4(x0+x2)
estado[1] = xtime((estado[1] ^ estado[3]));
//4(x1+x3)
estado[2] = xtime((estado[0] ^ estado[1]));
//8(x0+x1+x2+x3)
for(i=0;i<4;i++)
salida[i] ^= estado[2] ^ estado[i%2];
for(i=0;i<4;i++)
estado[i] = salida[i];
*/
/*
//MEJORA 32BITS + MEJORA XTIME
unsigned int a,b,c,d,aux;
a = estado[0];
b = estado[1];
c = estado[2];
d = estado[3];
aux = Multiply(a, 0x0e0e0e0e) ^ Multiply(b, 0x0b0b0b0b);
aux = aux ^ Multiply(c, 0x0d0d0d0d);
estado[0] = aux ^ Multiply(d, 0x09090909);
aux = Multiply(a, 0x09090909) ^ Multiply(b, 0x0e0e0e0e);
aux = aux ^ Multiply(c, 0x0b0b0b0b);
estado[1] = aux ^ Multiply(d, 0x0d0d0d0d);
aux = Multiply(a, 0x0d0d0d0d) ^ Multiply(b, 0x09090909);
aux = aux ^ Multiply(c, 0x0e0e0e0e);
estado[2] = aux ^ Multiply(d, 0x0b0b0b0b);
aux = Multiply(a, 0x0b0b0b0b) ^ Multiply(b, 0x0d0d0d0d);
aux = aux ^ Multiply(c, 0x09090909);
estado[3] = aux ^ Multiply(d, 0x0e0e0e0e);
*/
/*
//MEJORA 32BITS
unsigned int a,b,c,d,aux;
a = estado[0];
b = estado[1];
c = estado[2];
d = estado[3];
aux = (Multiply(a&0x000000FF, 0x0e) ^
Multiply(((a>>8)&0x000000FF)<<8, 0x0e) ^
Multiply(((a>>16)&0x000000FF)<<16, 0x0e) ^
Multiply(((a>>24)&0x000000FF)<<24, 0x0e))
^ (Multiply(b&0x000000FF, 0x0b) ^
Multiply(((b>>8)&0x000000FF)<<8, 0x0b) ^
Multiply(((b>>16)&0x000000FF)<<16, 0x0b) ^
Multiply(((b>>24)&0x000000FF)<<24, 0x0b));
aux = aux ^ (Multiply(c&0x000000FF, 0x0d) ^
Multiply(((c>>8)&0x000000FF)<<8, 0x0d) ^
Multiply(((c>>16)&0x000000FF)<<16, 0x0d) ^
Multiply(((c>>24)&0x000000FF)<<24, 0x0d));
estado[0] = aux ^ (Multiply(d&0x000000FF, 0x09) ^
171 | P á g i n a
Multiply(((d>>8)&0x000000FF)<<8, 0x09) ^
Multiply(((d>>16)&0x000000FF)<<16, 0x09) ^
Multiply(((d>>24)&0x000000FF)<<24, 0x09));
aux = (Multiply(a&0x000000FF, 0x09) ^
Multiply(((a>>8)&0x000000FF)<<8, 0x09) ^
Multiply(((a>>16)&0x000000FF)<<16, 0x09) ^
Multiply(((a>>24)&0x000000FF)<<24, 0x09))
^ (Multiply(b&0x000000FF, 0x0e) ^
Multiply(((b>>8)&0x000000FF)<<8, 0x0e) ^
Multiply(((b>>16)&0x000000FF)<<16, 0x0e) ^
Multiply(((b>>24)&0x000000FF)<<24, 0x0e));
aux = aux ^ (Multiply(c&0x000000FF, 0x0b) ^
Multiply(((c>>8)&0x000000FF)<<8, 0x0b) ^
Multiply(((c>>16)&0x000000FF)<<16, 0x0b) ^
Multiply(((c>>24)&0x000000FF)<<24, 0x0b));
estado[1] = aux ^ (Multiply(d&0x000000FF, 0x0d) ^
Multiply(((d>>8)&0x000000FF)<<8, 0x0d) ^
Multiply(((d>>16)&0x000000FF)<<16, 0x0d) ^
Multiply(((d>>24)&0x000000FF)<<24, 0x0d));
aux = (Multiply(a&0x000000FF, 0x0d) ^
Multiply(((a>>8)&0x000000FF)<<8, 0x0d) ^
Multiply(((a>>16)&0x000000FF)<<16, 0x0d) ^
Multiply(((a>>24)&0x000000FF)<<24, 0x0d))
^ (Multiply(b&0x000000FF, 0x09) ^
Multiply(((b>>8)&0x000000FF)<<8, 0x09) ^
Multiply(((b>>16)&0x000000FF)<<16, 0x09) ^
Multiply(((b>>24)&0x000000FF)<<24, 0x09));
aux = aux ^ (Multiply(c&0x000000FF, 0x0e) ^
Multiply(((c>>8)&0x000000FF)<<8, 0x0e) ^
Multiply(((c>>16)&0x000000FF)<<16, 0x0e) ^
Multiply(((c>>24)&0x000000FF)<<24, 0x0e));
estado[2] = aux ^ (Multiply(d&0x000000FF, 0x0b) ^
Multiply(((d>>8)&0x000000FF)<<8, 0x0b) ^
Multiply(((d>>16)&0x000000FF)<<16, 0x0b) ^
Multiply(((d>>24)&0x000000FF)<<24, 0x0b));
aux = (Multiply(a&0x000000FF, 0x0b) ^
Multiply(((a>>8)&0x000000FF)<<8, 0x0b) ^
Multiply(((a>>16)&0x000000FF)<<16, 0x0b) ^
Multiply(((a>>24)&0x000000FF)<<24, 0x0b))
^ (Multiply(b&0x000000FF, 0x0d) ^
Multiply(((b>>8)&0x000000FF)<<8, 0x0d) ^
Multiply(((b>>16)&0x000000FF)<<16, 0x0d) ^
Multiply(((b>>24)&0x000000FF)<<24, 0x0d));
aux = aux ^ (Multiply(c&0x000000FF, 0x09) ^
Multiply(((c>>8)&0x000000FF)<<8, 0x09) ^
Multiply(((c>>16)&0x000000FF)<<16, 0x09) ^
Multiply(((c>>24)&0x000000FF)<<24, 0x09));
estado[3] = aux ^ (Multiply(d&0x000000FF, 0x0e) ^
Multiply(((d>>8)&0x000000FF)<<8, 0x0e) ^
Multiply(((d>>16)&0x000000FF)<<16, 0x0e) ^
Multiply(((d>>24)&0x000000FF)<<24, 0x0e));
*/
}
172 | P á g i n a
Main.h
/**
* Metodo principal del programa
*/
int main(void);
/**
* modifica el valor del bloque a codificar a partir
de la palabraRecibida y ocupandose de los
caracteres ascii
*/
void fijaBloque(void);
/**
* a partir de un caracter codificado en ascii,
devuelve el valor numérico de ese caracter
*/
unsigned char leeCifra(unsigned char caracter);
/**
* modifica el valor de palabraRecibida
* y asigna 1 al valor de nuevaPalabra
*/
void setPalabraRecibida(unsigned char nuevo[]);
/**
* a partir de un numero da su codificacion en ascii
*/
unsigned char leeChar(unsigned char caracter);
Aes.h
/**
* fija el bloque a codificar
*/
void setEstado(unsigned char entrada[16]);
/**
* devuelve el bloque de codificacion en un puntero a un array de 4 int
*/
unsigned int* getEstado(void);
/**
* Esta funcion produce las Nb(Nr+1) subclaves (round keys) traspuestas
que se usan en cada ronda de encriptado
*/
void keyExpansion(void);
/**
* Suma la subclave de ronda al estado con una operación XOR
173 | P á g i n a
*/
void addRoundKey(char round);
/**
* La funcion SubBytes sustituye los valores de la matriz de estado por
sus respectivas correspondencias de la S-box
*/
void subBytes(void);
/**
* La funcion InvSubBytes es la inversa de la funcion SubBytes
* Por tanto sustituye los valores de la matriz de estado por sus
respectivas correspondencias en la iS-box
*/
void invSubBytes(void);
/**
* La funcion ShiftRows() rota las filas en la matriz de estado a la
izquierda
* cada fila es rotada tantos bytes como indice tiene, por lo que no se
rota la firmera fila
*/
void shiftRows(void);
/**
* La funcion InvShiftRows() es la inversa de la funcion ShiftRows()
* por tanto rota las filas en la matriz de estado a la derecha
* cada fila es rotada tantos bytes como indice tiene, por lo que no se
rota la firmera fila
*/
void invShiftRows(void);
/**
* La funcion MixColumns mezcla las columnas de la matriz de estado
multiplicandolas por distintos valores
*/
void mixColumns(void);
/**
* La funcion InvMixColumns es la inversa de la funcion MixColumns
* Por tanto mezcla las columnas de la matriz de estado multiplicandolas
por otros valores
*/
void invMixColumns(void);