Modelo de Criptoprocesador de Curvas Elípticas en … · 3.4 Extensión del repertorio de...

MODELO DE CRIPTOPROCESADOR DE CURVAS ELÍPTICAS EN GF(2m) BASADO

EN HARDWARE RECONFIGURABLE

Francisco Javier Brotons Molinero

www.ua.es

www.eltallerdigital.com

MODELO DE CRIPTOPROCESADOR

DE CURVAS ELÍPTICAS EN

GF(2m) BASADO EN HARDWARE

RECONFIGURABLE

FRANCISCO JAVIER BROTONS MOLINERO

TESIS DOCTORAL

ALICANTE, ENERO DE 2016

DEPARTAMENTO DE TECNOLOGÍA INFORMÁTICA

Y COMPUTACIÓN

ESCUELA POLITÉCNICA SUPERIOR

MODELO DE CRIPTOPROCESADOR DE

CURVAS ELÍPTICAS EN GF(2m) BASADO

EN HARDWARE RECONFIGURABLE FRANCISCO JAVIER BROTONS MOLINERO

Tesis presentada para aspirar al grado de

DOCTOR POR LA UNIVERSIDAD DE ALICANTE

INGENIERÍA INFORMÁTICA Y COMPUTACIÓN

DIRIGIDA POR:

DR. F. ÁNGEL GREDIAGA OLIVO DR. BERNARDO LEDESMA LATORRE

A la memoria de mis padres

III

AGRADECIMIENTOS

Con el tiempo, el número de personas que terminan ayudándote de una u otra forma es muy grande. Citar solamente y de forma específica a algunas de ellas terminaría por ser terriblemente injusto. Estoy seguro que me dejaría a otras muchas que también lo merecerían.

Así que a todas ellas, que seguro que saben quiénes son, gracias.

Y como la lista ya es mucho más corta, sí que quiero destacar a mis directores de tesis, Ángel y Bernardo, porque sin ellos probablemente no hubiera podido realizar este trabajo.

Muchas gracias.

V

RESUMEN En la presente tesis se ha llevado a cabo una investigación en el ámbito de la criptografía centrada en los criptosistemas basados en curvas elípticas. En concreto, se ha desarrollado un modelo de criptoprocesador de curvas elípticas en GF(2m) con el objetivo de abordar los requisitos, cada vez más en boga, de utilizar la menor cantidad de recursos posible y a la vez minimizar los tiempos de respuesta obtenidos. De forma más específica, uno de los objetivos se dirige a desarrollar un multiplicador capaz de trabajar de forma eficiente en cualquier campo GF(2m) independientemente de cuál sea el tamaño de palabra seleccionado para operar.

Para llevar a cabo este objetivo se ha realizado un análisis de los antecedentes y de los trabajos relacionados con el ámbito de la problemática predefinida. Este análisis nos ha permitido centrar el problema y a partir de éste plantear una solución novedosa con respecto al resto de enfoques existentes en este campo de investigación.

Se ha implementado un microprocesador de 8 bits de propósito general en hardware reconfigurable minimizando su repertorio de instrucciones. A partir de él se han obtenido los resultados que nos proporcionan su programación en el lenguaje ensamblador descrito y

VI

se propone como propuesta de mejora la inclusión de un elemento multiplicador que disminuya los tiempos de respuesta. Para ello se introducen los multiplicadores existentes en la actualidad; tanto de tipo paralelo como serie.

Posteriormente, como propuesta de mejora real, se ha desarrollado un multiplicador hardware específico capaz de trabajar en GF(2m) y con reducción intercalada que puede ser utilizado en cualquier sistema sea cual sea su campo de trabajo e independientemente del tamaño de palabra que utilice. Este multiplicador se ha implementado con diferentes tamaños de palabra y en los campos finitos de característica 2 recomendados por el N.I.S.T.

Como paso final para validar este multiplicador se ha implementado varios modelos de un criptoprocesador con un repertorio de instrucciones específico con diferentes tamaños de palabra y en diferentes campos y se han comparado con los existentes para comprobar la eficiencia de la propuesta.

VII

ABSTRACT

In this thesis it has been carried out a research in the field of cryptography focused on the cryptosystems based on elliptic curves. Specifically, we have developed a model of elliptic curves in GF(2m) in order to reach the requirements, increasingly in vogue, to use the least amount of resources possible while minimizing the response times achieved. More specifically, one of the objectives is centered on developing a multiplier able to work efficiently in any field GF(2m) regardless of the size of the word selected to operate.

To carry out this objective has made an analysis of the state of art and works related to the field of the predefined problems. This analysis has allowed us to focus the problem and from this propose a novel solution with respect to other existing approaches in this field of research.

It has implemented a general purpose 8-bit microprocessor on reconfigurable hardware minimizing his instructions set. From the results that provide its programming in the language assembler described, is presented as proposed improvement the inclusion of a

VIII

multiplier element to decrease response times. For this, multipliers existing today are introduced; both parallel and series type.

Subsequently, as proposed real improvement, it has developed a hardware multiplier specific able to work in GF GF(2m) and interleaved reduction that can be used in any system whatever their field of work and regardless of the size of word use. This multiplier has been implemented with different word sizes and the finite fields of characteristic two recommended by the NIST.

As a final step to validate this multiplier has implemented several models of a cryptoprocessor with a repertoire of specific instructions set with different word sizes and in different fields and compared with existing to check the efficiency of the proposal.

IX

ÍNDICE

CONTENIDO Resumen V

Abstract VII

Índice. Contenido IX

Índice. Figura y Tablas XIII

Figuras XIII

Tablas XVI

Estructura del Documento 1

Capítulo 1. Introducción. Objetivos y Estado del Arte 3

1.1 Motivación 3

1.2 Estado del Arte 5

1.2.1 Implementaciones Hardware 5

1.3 Criptografía de Clave Pública 8

1.3.1 Modelo Básico 9

1.3.2 Comparación RSA-ECC 12

Criptosistema RSA 13

Seguridad 15

ÍNDICE

X

Eficiencia 20

Requisitos de Espacio 20

1.4 Identificación del Problema 22

1.5 Objetivos 23

Capítulo 2. Fundamentos Teóricos 25

2.1 Cuerpos Finitos 25

2.1.1 El Cuerpo Finito GF(p) 27

2.1.2 El Cuerpo Finito GF(2m) 29

2.1.3 Aritmética en el Campo Finito GF(2m) Utilizando Base Polinomial 32

2.2 Curvas Elípticas 38

2.2.1 Coordenadas Afines vs. Proyectivas 41

2.2.2 Elección de los Parámetros de la Curva 42

2.2.3 Curvas Elípticas sobre GF(p) 44

2.2.4 Curvas Elípticas sobre GF(2m) 46

2.2.5 Multiplicación de puntos de una Curva Elíptica 47

Capítulo 3. Codiseño Hardware-Software. Primera aproximación. 53

3.1 Plataforma de Desarrollo 54

3.2 Consideraciones Previas de la Implementación 60

3.3 Aritmética del campo 61

3.4 Extensión del repertorio de instrucciones 65

3.4.1 Multiplicador Paralelo 67

3.4.2 Multiplicador Serie 71

3.5 Conclusiones 73

Capítulo 4. Propuesta de Modelo de Criptoprocesador en GF(2m) 75

4.1 IEEE P1363: El Estándar de la Criptografía de Clave Pública 76

4.1.1 Logaritmo Discreto (DL) 77

4.1.2 Factorización de Enteros (IF) 78

ÍNDICE

XI

4.1.3 Logaritmo Discreto sobre Curvas Elípticas (ECDL) 79

4.2 Definición de la Arquitectura y del Conjunto de Instrucciones 79

4.3 Arquitectura 82

4.4 Implementación de los Operadores 84

4.4.1 Sumador/Comparador 84

4.4.2 Multiplicador 86

Multiplicadores de bits en serie en GF(2m) 87

Multiplicadores de dígitos en serie en GF(2m) 92

4.4.3 Propuesta de multiplicador de dígitos en serie en GF(2m) 95

Ejemplo del Algoritmo de Multiplicación Propuesto 105

Generalización del Algoritmo de Multiplicación Propuesto 107

4.4.4 Cuadrado 110

4.4.5 Inversión 112

4.4.6 División 113

4.4.7 Suma de dos puntos de una Curva Elíptica 114

4.4.8 Duplicado de un punto de una Curva Elíptica 115

4.5 Descripción del formato de instrucción 116

4.6 Descripción detallada de las instrucciones 118

Capítulo 5. Experimentos. Validación del Modelo 127

5.1 Implementación del multiplicador básico 128

5.2 Implementación del multiplicador con reducción intercalada 129

5.3 Implementación del modelo de Criptoprocesador 133

5.4 Análisis de resultados 135

Capítulo 6. Conclusiones 139

6.1 Trabajos Futuros 140

BIBLIOGRAFÍA 143

ÍNDICE

XIII

ÍNDICE

FIGURAS Y TABLAS FIGURAS

Figura 1.1 – Andrés y Beatriz mantienen una comunicación ............................. 10

Figura 2.1 – Representación gráfica de una curva sobre números reales .... 39

Figura 2.2 – Suma de los puntos P y Q de una curva elíptica.............................. 40

Figura 2.3 – Doblado de un punto P de una curva elíptica .................................. 40

Figura 2.4 – Niveles de decisión en un criptosistema basado en curvas elípticas ...................................................................................................................................... 43

Figura 3.1 – Estructura interna........................................................................................ 55

Figura 3.2 – Unidad de control obtenida ..................................................................... 58

Figura 3.3 – Unidad Aritmético-Lógica ........................................................................ 59

Figura 3.4 – Obtención de de A * B ................................................................................. 62

Figura 3.5 – Obtención del cuadrado de A .................................................................. 63

ÍNDICE

XIV

Figura 3.6 – Estructura interna con el bloque extensor ....................................... 66

Figura 3.7 – Estructura del bloque multiplicador ................................................... 67

Figura 3.8 – Estructura resultante del bloque multiplicador de 8 bits por 8 bits ................................................................................................................................................ 70

Figura 3.9 – Estructura resultante multiplicador LSB de 163 bits .................. 72

Figura 4.1 – Funcionalidad de un criptosistema basado en curvas elípticas ...................................................................................................................................... 80

Figura 4.2 – Interacción entre las diferentes operaciones .................................. 81

Figura 4.3 – Visión general de la arquitectura del procesador .......................... 82

Figura 4.4 – Ruta de datos .................................................................................................. 84

Figura 4.5 – Suma en GF(2m). ............................................................................................ 85

Figura 4.6 – Multiplicador LSB de m bits en serie ................................................... 90

Figura 4.7 – Multiplicador MSB de m bits en serie ................................................. 92

Figura 4.8 – Multiplicación de los bits de A2 por los de B2 .................................. 96

Figura 4.9 – Multiplicación de los bits de A2 por los de B1 .................................. 97

Figura 4.10 – Obtención del producto de A2 por B0 ................................................ 97

Figura 4.11 – Reducción del producto de A2 por B ................................................. 98

Figura 4.12 – Producto reducido de A2 por B ............................................................ 98

Figura 4.13 – Producto de A2 × B .................................................................................... 99

Figura 4.14 – Producto de A1 por B ..............................................................................100

Figura 4.15 – Producto acumulado reducido de los dos primeros dígitos .100

Figura 4.16 – Producto de A1 × B ..................................................................................101

Figura 4.17 – Ubicación del producto de A1 y A2 por B .......................................101

Figura 4.18 – Producto de A por B previo a la reducción final ........................102

Figura 4.19 – Última reducción y obtención del resultado final .....................102

Figura 4.20 – Producto de A0 × B ..................................................................................103

Figura 4.21 – Diagrama de bloques del multiplicador con reducción intercalada ..............................................................................................................................105

ÍNDICE

XV

Figura 4.22 – Diagrama de bloques del multiplicador generalizado ............108

Figura 4.23 – Circuito para la obtención del cuadrado en GF(2163) ..............111

Figura 4.24 – Estructura del inversor implementado .........................................112

Figura 4.25 – Formato General de las instrucciones ............................................116

Figura 4.26 - Formato de la instrucción de Suma ..................................................118

Figura 4.27 - Formato de la instrucción de Multiplicación ...............................119

Figura 4.28 - Formato de la instrucción de Inversión .........................................119

Figura 4.29 - Formato de la instrucción del Cuadrado ........................................120

Figura 4.30 - Formato de la instrucción de División ............................................120

Figura 4.31 - Formato de la instrucción de Establecimiento de Campo ......121

Figura 4.32 - Formato de la instrucción de Duplicado de un punto de la curva elíptica ..........................................................................................................................121

Figura 4.33 - Formato de la instrucción de Suma de dos puntos de la curva elíptica. ....................................................................................................................................124

Figura 4.34 - Formato de la instrucción de Copia de contenido de un registro ....................................................................................................................................124

Figura 4.35 - Formato de la instrucción de Carga de datos...............................125

Figura 4.36 - Formato de la instrucción de Transferencia de datos al exterior ....................................................................................................................................125

Figura 4.37 - Formato de la instrucción de Comparación .................................126

Figura 4.38 - Formato de la instrucción de Salto ...................................................126

Figura 4.39 - Formato de la instrucción de Salto Condicional .........................126

Figura 5.1 – Tiempo de respuesta del multiplicador en función del número de bits ....................................................................................................................................129

Figura 5.2 – Ciclos de reloj necesarios en Multiplicador con Reducción Intercalada para los diferentes campos de trabajo y tamaño de palabra. ..130

Figura 5.3 – Número de Slices utilizados en un FPGA Xilinx Spartan SC3S500E.................................................................................................................................131

ÍNDICE

XVI

Figura 5.4 – Producto Tiempo-ocupación para las diferentes implementaciones ...............................................................................................................131

TABLAS

Tabla 1.1 - Capacidad de cálculo requerida para factorizar enteros utilizando el algoritmo general de criba del cuerpo de números..................... 14

Tabla 2.2 - Potencia de cálculo requerida para la obtención del logaritmo elíptico con el método Rho de Pollard. ......................................................................... 15

Tabla 1.3 - Comparación entre la fortaleza de las clave según su tamaño ... 17

Tabla 1.4 - Requisitos de espacio .................................................................................... 19

Tabla 1.5 - Tamaños de firma para un mensaje de 2000 bits ............................ 19

Tabla 1.6 - Tamaño de un mensaje encriptado de 100 bits ................................ 19

Tabla 2.1: Algoritmo de suma en GF(p) ....................................................................... 27

Tabla 2.2: Algoritmo de resta en GF(p) ........................................................................ 28

Tabla 2.3: Algoritmo de multiplicación en GF(p) ..................................................... 30

Tabla 2.4: Algoritmo para la suma en GF(2m) ........................................................... 32

Tabla 2.5: Algoritmo de reducción modular en GF(2m) ........................................ 33

Tabla 2.6: Algoritmo para la obtención del cuadrado en GF(2m) ..................... 33

Tabla 2.7: Algoritmo de multiplicación en GF(2m) .................................................. 34

Tabla 2.8: Algoritmo extendido de Euclides .............................................................. 35

Tabla 2.9: Algoritmo casi inverso ................................................................................... 37

Tabla 2.10: Algoritmo casi inverso modificado ........................................................ 38

Tabla 2.11: Algoritmo de suma de puntos en GF(p) ............................................... 45

Tabla 2.12: Algoritmo de suma de puntos en GF(2m) ............................................ 47

Tabla 2.13: Método binario para la multiplicación de puntos ........................... 48

Tabla 2.14: Obtención de la forma no adyacente de un entero positivo ....... 49

ÍNDICE

XVII

Tabla 2.15: Método NAF para la multiplicación de puntos ................................. 49

Tabla 2.16: Método de Montgomery para la multiplicación de puntos ......... 50

Tabla 3.1: Repertorio de Instrucciones Implementado ........................................ 56

Tabla 3.2: Porcentajes de utilización de elementos en el FPGA ....................... 60

Tabla 3.3: Obtención de a-1 mediante el algoritmo de Itoh-Tsujii .................... 64

Tabla 3.4: Coste de las operaciones realizadas en software ............................... 64

Tabla 3.5: Coste de las operaciones realizadas en software necesarias para la multiplicación escalar ..................................................................................................... 65

Tabla 3.6: Elementos utilizados en función del tamaño del multiplicador .. 65

Tabla 3.7: Ciclos de reloj en función del tamaño del multiplicador ................ 69

Tabla 3.8: Ocupación para un multiplicador serie de 163 × 163 bits ............. 71

Tabla 4.1: Tamaños de campo recomendado y polinomio reductor asociado ..................................................................................................................................... 83

Tabla 4.2: Algoritmo para la suma en GF(2m) ........................................................... 88

Tabla 4.3: Algoritmo de multiplicación LSB en GF(2m) ......................................... 89

Tabla 4.4: Algoritmo de multiplicación MSD en GF(2m) ....................................... 94

Tabla 4.5: Algoritmo de multiplicación con reducción intercalada ...............104

Tabla 4.6: Algoritmo de multiplicación generalizado ..........................................110

Tabla 4.7: Secuencia de operaciones para la división. ........................................113

Tabla 4.8: Secuencia de operaciones para la suma de puntos de la curva ....................................................................................................................................114

Tabla 4.9: Secuencia de operaciones para el duplicado de un punto de la curva. ....................................................................................................................................115

Tabla 4.10: Tipo de Registro y codificación utilizada. .........................................117

Tabla 4.11: Secuencia de instrucciones para el duplicado de un punto de la curva. ....................................................................................................................................122

Tabla 4.12: Secuencia de instrucciones para la suma de puntos de la curva ....................................................................................................................................123

ÍNDICE

XVIII

Tabla 5.1: Tiempo de respuesta y frecuencia de funcionamiento del elemento multiplicador. ....................................................................................................128

Tabla 5.2: Ciclos de reloh necesarios en el Multiplicador con Reducción Intercalada para los diferentes campos de trabajo y tamaño de palabra. ..130

Tabla 5.3: Slices LUT de ocupación por parte de cada uno de los elementos en función del campo de trabajo (m)......................................................................................... 133

Tabla 5.4: Número de ciclos de reloj necesario para la ejecución de las operaciones en función del campo de trabajo (m) ................................................134

Tabla 5.5: Tiempos de ejecución del producto escalar (ms) ............................135

ESTRUCTURA DEL DOCUMENTO

En esta tesis utilizaremos la criptografía basada en curvas elípticas como base para desarrollar una propuesta de criptoprocesador capaz de trabajar en campos finitos de característica 2. Para tratar los aspectos fundamentales de los trabajos realizados, se ha estructurado esta memoria en capítulos que tratan de forma individual las diferentes tareas conforme a los objetivos propuestos.

En el capítulo 1 se abordan el estudio de los antecedentes haciendo una introducción al estado del arte, comenzando por una revisión de las principales implementaciones hardware de criptosistemas de clave pública desde los primeros sistemas basados en RSA. Posteriormente se realiza una descripción comparativa entre los criptosistemas basados en RSA y los basados en curvas elípticas que nos ayudan a ubicarnos en su situación actual.

En el capítulo 2 se presenta una breve introducción a los fundamentos teóricos de las curvas elípticas sobre campos finitos y sus operaciones de grupo que nos servirán como marco para poder operar. Basándonos en ellos se exponen los diferentes algoritmos que pueden utilizarse para la instanciación de la aritmética sobre campos finitos y la aritmética de puntos. Haremos especial hincapié en aquellos que resultan interesantes para el desarrollo de la tesis.

En el capítulo 3 propondremos el modelado de un microprocesador de 8 bits en VHDL como plataforma inicial de trabajo del criptosistema. Una vez desarrollado plasmaremos sobre él los algoritmos capaces de realizar las operaciones necesarias trabajando sobre coordenadas afines y utilizando como base una tarjeta Nexys 2 de Digilent. Observaremos sus carencias y propondremos las posibles modificaciones que permitan mejorar el funcionamiento y sus tiempos de respuesta.

Ante los resultados obtenidos en el capítulo 3, en el capítulo 4 se realiza el modelado de un criptoprocesador de curvas elípticas capaz de operar en cualquier campo utilizando coordenadas afines. Para ello previamente realizamos un análisis de los operadores necesarios y sus posibles configuraciones, plasmando una propuesta de multiplicador con reducción intercalada que si bien inicialmente es capaz de trabajar en un campo que sea múltiplo de su tamaño de palabra, luego se ha generalizado para que pueda hacerlo de forma independiente de él. Atendiendo a las necesidades se expone el repertorio de instrucciones que deberá tener así como su formato y descripción detallada.

Una vez propuesto el modelo, en el capítulo 5 comprobamos experimentalmente su funcionamiento y obtenemos sus necesidades de espacio así como los tiempos de respuesta que es capaz de ofrecernos para una multiplicación escalar de forma empírica. Para ello se realizan las siguientes tareas.

• Descripción en VHDL del multiplicador con reducción intercalada de forma parametrizada para que pueda trabajar con cualquier tamaño de palabra y en cualquier campo finito de característica 2.

• Implementación física del multiplicador sobre un FPGA que nos permita obtener resultados reales.

• Descripción y comprobación del funcionamiento individual de los diferentes elementos que componen el modelo de criptoprocesador.

• Integración de los componentes y derivación de resultados del módulo obtenido, tanto de ocupación como de tiempos de respuesta, en las diferentes posibilidades de campo de trabajo en un rango que va desde los 113 hasta los 409 bits.

Finalmente, dedicaremos el capítulo 6 a exponer las principales conclusiones y aportaciones del trabajo así como a plantear las principales líneas de investigación que se desprenden del mismo.

3

CAPÍTULO 1

INTRODUCCIÓN: OBJETIVOS Y ESTADO DEL ARTE

1.1 MOTIVACIÓN Los últimos avances tecnológicos en materia de hardware reconfigurable hacen que su utilización se haya vuelto muy atractiva en una amplia gama de aplicaciones. Hoy por hoy, los dispositivos programables pueden adaptarse y utilizarse para el diseño e implementación de circuitos digitales de gran tamaño, obteniéndose velocidades de funcionamiento e índices de prestaciones más que considerables. Al mismo tiempo, Internet ha alcanzado un crecimiento y popularidad que ha provocado que las redes de computadores, el comercio electrónico o la banca electrónica sean de uso cotidiano y que los documentos se presenten en formato electrónico. Pero un entorno abierto, como es Internet, representa un riesgo para sus usuarios pues pone en peligro la privacidad y la integridad de la información enviada en cada transacción. La necesidad de seguridad ha contribuido a la investigación en el área de los protocolos criptográficos y los algoritmos de encriptación, pero aun así Internet presenta un entorno diverso, con


4

sistemas heterogéneos que imposibilitan encontrar un algoritmo que cumpla las necesidades de todos los usuarios. Consecuentemente, se hace obvia la necesidad de una aproximación versátil a los servicios criptográficos.

Por fortuna, la computación reconfigurable nos da posibilidad de realizar implementaciones criptográficas que cumplan las especificaciones impuestas por un entorno real. Los dispositivos reconfigurables son de particular interés en estas aplicaciones criptográficas debido a su alto grado de flexibilidad si los comparamos con las soluciones ASIC alternativas.

La mayoría de los protocolos criptográficos modernos como pueden ser 3-D Secure, IPSEC o SSL están definidos de forma que son algorítmicamente independientes. Esto significa que para un mismo servicio de seguridad pueden utilizarse diferentes algoritmos. Por ejemplo, un determinado protocolo puede admitir RSA, DSA o curvas elípticas como algoritmo de firma digital. Adicionalmente, los sistemas de hoy en día presentan un enfoque híbrido, utilizando conjuntamente tanto sistemas de clave privada como de clave pública.

Una tercera razón que hace a los dispositivos reconfigurables muy atractivos en las aplicaciones criptográficas es que virtualmente, todos los parámetros del diseño pueden modificarse. Por ejemplo, la implementación de sistemas basados en curvas elípticas en un entorno reconfigurable implica que tendremos la posibilidad de alterar los parámetros de la curva para cada encriptado individual. Además, las funciones aritméticas subyacentes, como son los multiplicadores de campos finitos y los sumadores, podrán cambiarse atendiendo al orden del campo o la base en que se haga la representación. Por tanto, las implementaciones basadas en hardware reconfigurable preservan la flexibilidad del software, incorporando la seguridad y velocidad del hardware. Adicionalmente, la aparición de dispositivos con posibilidad de reconfiguración parcial permite incluso la posibilidad de acomodar diferentes esquemas en el mismo dispositivo y reconfigurar solamente las funciones que necesitemos sin necesidad de sustituirlo.

El trabajo descrito en esta tesis presenta una propuesta de modelado basado en curvas elípticas en un Field Programmable Gate Array (FPGA), área en la que se han desarrollado diversos trabajos en los últimos años. El uso de curvas elípticas en algoritmos criptográficos se inició hace algo más de 20 años y resulta ventajoso por muchas razones. En primer lugar encontramos

CAPÍTULO 1

5

que utiliza longitudes de clave de tamaño reducido sin comprometer la seguridad del sistema. Si lo comparamos con los métodos convencionales de encriptado de clave pública como es RSA y los sistemas basados en el problema del logaritmo discreto, encontramos que el tamaño de la clave es del orden de más de 6 veces menor. Esto siempre se traducirá en un incremento de las prestaciones. Posteriormente realizaremos una comparación entre RSA y ECC como justificación del uso de éstas últimas.

1.2 ESTADO DEL ARTE En este apartado se presenta una revisión de los trabajos que abordan problemas similares al propuesto y que teniendo relación con el problema planteado puedan servir como referencia del estado en que se encuentra la investigación relacionada.

Se han revisado, por su relación inmediata con el marco en el que se desarrolla la investigación, trabajos sobre criptografía de clave pública de que utilicen técnicas basadas en curvas elípticas si bien no se pueden ignorar algunos basados en RSA puesto que fueron los primeros en aparecer y los que dieron pie al desarrollo posterior de las técnicas basadas en curvas elípticas. De igual modo, se han incluido los trabajos relacionados con los operadores encargados de realizar las principales operaciones aritméticas en campos finitos.

1.2.1 IMPLEMENTACIONES HARDWARE

La literatura relacionada con la implementación hardware de sistemas criptográficos es muy vasta. Todos los trabajos iniciales están basados en RSA. El que podemos considerar como el primero, fue propuesto por Rivest, Shamir y Adleman en 1980. Estaba compuesto por unos 40000 transistores y aunque tenía problemas de funcionamiento, sirvió como punto de partida de numerosos diseños VLSI [1].

En 1985, Kochanski [2] propuso un chip RSA en el que la exponenciación modular se realizaba entre una matriz de transistores CMOS y un microprocesador. La multiplicación modular se realizaba en la matriz CMOS bajo el control del microprocesador, que se encargaba finalmente de realizar la exponenciación.


6

Uno de los primeros procesadores RSA fue presentado por Hoornaert et al. [3], implementado mediante 120 bit-slice, que podían configurar para trabajar con diferentes longitudes de palabra.

El concepto de hardware escalable fue introducido por los trabajos de Tenca y Koç [4], [5]. Los autores describen un multiplicador de Montgomery que tiene la posibilidad de trabajar con cualquier tamaño de operando, pudiendo ajustarse en función del área disponible o al nivel de prestaciones que se requiera. Proponen un algoritmo en el que el multiplicando se toma de palabra en palabra y se opera con el multiplicador, que se toma bit a bit.

Dentro del campo de las curvas elípticas también podemos encontrar numerosos trabajos relacionados con la integración de procesadores en FPGA. En su mayoría tratan de profundizar en técnicas de aceleración y optimización de los algoritmos básicos. Probablemente, la primera implementación de un criptoprocesador de curvas elípticas fue la presentada por Gao [6] en 1999 y utilizaba la base normal para representar los elementos del campo finito y un multiplicador de Massey-Omura [7] para realizar el producto de dos elementos del campo.

En 2000 Orlando & Paar [8] presentaron un procesador reconfigurable capaz de operar en cualquier campo mediante la reconfiguración que empleaba el algoritmo de Montgomery para la multiplicación escalar. La multiplicación en el campo finito seleccionado se realiza utilizando el multiplicador de dígitos propuesto por Song y Parhi [9] y el algoritmo utilizado para la inversión es el de Itoh-Tsujii [10]. La multiplicación de puntos en GF(2167) se realiza en 0,21s.

En [11] Kerins et al. presentan un procesador parametrizable que puede utilizarse para cualquier polinomio irreducible sin necesidad de reconfiguración. El procesador comprende un coprocesador encargado de realizar la aritmética en el campo finito. Las operaciones implicadas en la suma y duplicado de puntos se realizan en la FPGA en comunicación con un PC host que se encarga de realizar la multiplicación escalar mediante duplicado de puntos y adiciones sucesivas. Esta implementación, si bien presenta una alta flexibilidad, es lenta y no alcanza los requisitos de velocidad exigidos por las aplicaciones de banda ancha. Una multiplicación de puntos de 239 bits requiere 12.8ms, lo que podemos considerar alto comparado con otras implementaciones publicadas.

CAPÍTULO 1

7

Bednara et al. describen en [12], un procesador ECC en el que se nos muestra la ruta de datos y sus operadores de suma, cuadrado y multiplicación. Los autores utilizan una representación híbrida para los puntos de la curva utilizando coordenadas afines, Jacobianas y de Lopez-Dahab y realizando un análisis área/prestaciones para los diferentes casos, presentando finalmente las coordenadas afines como las que mejor se adaptan para los objetivos buscados.

En [13], Gura et al. nos presentan un acelerador hardware para incrementar la velocidad en la multiplicación de puntos para curvas elípticas sobre campos binarios polinomiales de la forma GF(2m). El acelerador está basado en una arquitectura capaz de manejar curvas de grado arbitrario de un valor máximo de m = 255. El prototipo se materializó sobre una FPGA consiguiendo resultados de hasta 6987 multiplicaciones de puntos por segundo en GF(2163).

El procesador presentado por Lutz y Hasan [14] es capaz de realizar la multiplicación de puntos en 75µs en el campo GF(2163). También presentan los circuitos encargados de realizar el cuadrado y la inversión. El procesador utiliza coordenadas proyectivas y está optimizado para la implementación sobre un formato específico de curvas elípticas como son las curvas de Koblitz. En la literatura podemos encontrar diferentes técnicas de aceleración para este tipo de curvas [15], pero puesto que nuestro trabajo se enfoca hacia las curvas genéricas, estas técnicas no son aplicables y la comparación no será adecuada.

En [16] Saqib et al. presentan un procesador de alta velocidad para curvas elípticas para el campo GF(2191) en el que la multiplicación de puntos se podría realizar en 56,44 µs. Utiliza un multiplicador de Karatsuba para la multiplicación en el cuerpo finito. Sin embargo, no especifica ningún algoritmo para la inversión, quedando la implementación incompleta.

En [17] se nos presenta, alternativamente, una aproximación microprogramada de fácil modificación, cambio y optimización. El microcódigo se almacena en una RAM y no requiere recursos adicionales.

Integrando su prototipo en una tarjeta PCI, donde se realiza la encriptación y la desencriptación, Wang et al. [18] nos presentan un coprocesador descrito en Verilog HDL en el que proponen una arquitectura para la multiplicación modular en la que tratan de conjugar la multiplicación de bits


8

en serie y en paralelo, consiguiendo realizar una multiplicación escalar en 2,28 ms trabajando en GF(2233).

En [19], Chelton y Benaissa desarrollan un procesador para curvas elípticas que utiliza un algoritmo combinado para realizar el duplicado y la suma de puntos. Realiza la multiplicación escalar en 0.019 ms para una curva elíptica en GF(2163). Es de los más rápidos presentados en la literatura, pero presenta una estructura segmentada de siete niveles que tienen grandes requisitos de espacio.

Antao et al. [20] proponen una estructura capaz de realizar la suma y la multiplicación de puntos de la curva utilizando una coordenada única que contiene la información comprimida del punto con el que se trabaja. Presentan un prototipo sobre un dispositivo reconfigurable para GF(2163) capaz de realizar la multiplicación en 144µs y la suma en 102µs. Si bien los tiempos son interesantes, presenta el inconveniente del cálculo previo de la coordenada única.

En [21] se describe un procesador flexible para capaz de realizar la suma, la multiplicación y la inversión sobre GF(p), para los 5 primos recomendados por el NIST (192, 224, 256, 384 y 521). Implementado sobre FPGA, funciona a 60MHz y emplea, dependiendo del primo utilizado, entre 4 y 40 ms en realizar una multiplicación escalar.

Chuanpeng y Zhongping [22] introduce un procesador criptográfico para curvas genéricas en GF(p) basado en coordenadas afines. Emplea unidades sistólicas para la división y la multiplicación. Como aportación presenta que estas operaciones se realizan mediante un algoritmo que aúna la multiplicación y la división de Montgomery.

En [23] se nos presenta un procesador que incluye multiplicadores de dígitos operando en bases normales. Opera sobre curvas de Koblitz en GF(2163) y basa sus resultados en la inclusión de cuatro multiplicadores paralelizando la multiplicación de puntos. [24]

1.3 CRIPTOGRAFÍA DE CLAVE PÚBLICA

La criptografía es la ciencia de la codificación de mensajes con la finalidad de que partes no autorizadas no pueden descifrar la información codificada en

CAPÍTULO 1

9

una cantidad razonable de tiempo. Originalmente, la criptografía fue principalmente utilizada en el ámbito militar, buscando proporcionar canales de comunicación segura en ambientes hostiles. La mayoría de las técnicas de codificación resultantes se basaban en métodos ad-hoc, sin una medida cuantitativa de la seguridad ni en un sentido práctico ni teórico.

En los últimos 30 años, esta idea ha cambiado radicalmente y la criptografía se ha convertido en una disciplina de uso generalizado debido a su utilización en las comunicaciones digitales como medio para garantizar la seguridad.

Desgraciadamente, la criptografía muchas veces se ha considerado un arte oscuro y la base matemática necesaria en la que se basa tiende a disuadir a la mayoría de las personas de aprender más sobre este campo. Sin embargo, debido a la necesidad de que los canales de comunicación digital sean seguros por su uso cotidiano las transacciones financieras o el comercio electrónico, la criptografía está empezando a ser mucho más conocida debido a la creciente conciencia de los problemas de seguridad. Como resultado, se han desarrollado múltiples trabajos y disponemos de referencias excelentes y de fácil acceso dentro del mundo de la criptografía moderna y están disponibles para el lector (por ejemplo, [25], [26] o [27]). Esta sección intenta proporcionar una breve introducción a la materia, y destacar las ideas principales con el fin de fundamentar el trabajo presentado en esta tesis.

1.3.1 MODELO BÁSICO

La figura 1.1 describe una situación típica de sistema criptográfico inalámbrico. En ella, Andrés y Beatriz intentan establecer una comunicación privada en una red inalámbrica en presencia de una tercera parte no autorizada, Carlos. Con la finalidad de asegurar la privacidad, Andrés y Beatriz pueden utilizar varias técnicas criptográficas para asegurar la privacidad mediante el uso de varias funciones básicas:

• Autenticación de usuario: Andrés y Beatriz deben verificar que su interlocutor es quien dice ser y que Carlos no está haciéndose pasar por cualquiera de ellos.

• Establecimiento de clave: Una vez Andrés y Beatriz han verificado su identidad, deben ponerse de acuerdo sobre algún tipo de información secreta que solo ellos conocerán, y que no sabrá Carlos. Esta información se utilizará para crear una clave secreta común.


10

• Encriptado/desencriptado de datos: Con una clave secreta compartida, Andrés y Beatriz pueden utilizar algoritmos de encriptado de datos para codificar su comunicación. De esta forma, Carlos no podrá descifrar los mensajes, aunque sí que tendrá acceso a los mensajes codificados.

• Comprobación de la integridad de los datos y firma: Idealmente, Andrés y Beatriz deben de ser capaces de asegurarse de que los mensajes codificados que reciben son exactamente los que se han enviado entre ellos y no lo ha hecho Carlos.

La criptografía dispone de técnicas que nos permiten realizar todas estas funciones utilizando dos tipos de algoritmos (simétricos y asimétricos) que poseen distintas propiedades. Los algoritmos criptográficos asimétricos toman su nombre del hecho de que no se necesita compartir ninguna información secreta entre Andrés y Beatriz. Los algoritmos simétricos se basan en la existencia de funciones matemáticas que tienen la propiedad de que pueden calcularse de forma eficiente (es decir, con un tiempo polinomial), pero su inversión resulta computacionalmente inviable sin conocer alguna parte de la información secreta. El nombre formal para una función que muestra estas propiedades es la de función irreversible con clave. Es irreversible debido a la asimetría en la complejidad computacional en su cálculo directo e inverso, pero existe una clave secreta que permite realizar la inversión de forma eficiente. Esta asimetría se aprovecha para formar algoritmos que emplean dos claves: una pública, que se utiliza para la codificación directa de la información, y una privada (la secreta) que permite que la función se pueda invertir y, por tanto recuperar los datos que se habían codificado. Los algoritmos asimétricos comúnmente se denominan algoritmos de clave pública.

Figura 1.1 – Andrés y Beatriz mantienen una comunicación privada mientras Carlos la monitoriza

Andrés Beatriz

Carlos

CAPÍTULO 1

11

La separación de la clave en una componente pública y una privada permite tanto a Andrés como a Beatriz realizar la autenticación del usuario y de los datos mediante la inversión de la codificación y la decodificación: en lugar de aplicar la clave pública para codificar los datos y la clave privada para decodificar, la autenticación utiliza en primer lugar la clave privada para codificar y la clave pública para decodificar. Puesto que las dos operaciones son conmutativas, los resultados son los mismos independientemente de cuál se haya aplicado. Como la clave privada solo la conoce el usuario que ha generado el mensaje (es decir, Andrés o Beatriz), Carlos no puede suplantarlo sin adivinar la clave. De esta manera, tanto Andrés como Beatriz pueden autenticar su identidad añadiendo un simple mensaje (por ejemplo, “Hola, mi nombre es Beatriz/Andrés”) codificado con su clave privada, y luego enviar el mensaje codificado con la clave pública a la otra parte, que se puede decodificar con esta clave para verificar que el mensaje esperado es el que se ha recibido.

De forma similar, la autenticación del mensaje puede realizarse si su emisor codifica una representación digital del mismo mediante su clave privada, formando una firma digital para este mensaje. La firma se añade al mensaje codificado y se transmite al receptor, que lo decodifica, extrae la representación digital del mensaje y decodifica la firma para asegurarse de que coincide con el valor esperado. Cualquier alteración del mensaje transmitido se traducirá en que los dos valores no coincidirán y no podrán autenticarse los datos. Además, puesto que solo el emisor conoce el valor de su clave secreta para codificar la firma, una decodificación válida, también valida la autoría del mensaje.

Las técnicas asimétricas permiten a Andrés y a Beatriz generar una clave secreta en presencia de Carlos. Cada uno de ellos codifica un mensaje aleatorio utilizando la clave pública del otro e intercambiarán los mensajes. Andrés y Beatriz pueden decodificar el mensaje del otro y combinarlo de alguna forma predeterminada con su propio mensaje para generar una clave secreta compartida. Carlos solo verá los dos mensajes codificados, que asumiendo la intratabilidad de la inversión de la codificación de clave pública, no le permitirá derivar la misma clave secreta. De esta manera, Andrés y Beatriz han realizado un nuevo acuerdo de clave.

Desgraciadamente, los algoritmos asimétricos basan su seguridad en la dificultad de resolución del problema numérico sobre el que se han construido. Esto nos lleva a una limitación del grado de optimización que


12

puede aplicarse para mejorar las prestaciones de las funciones que implementa el algoritmo. Por tanto, los algoritmos asimétricos tienden a ser computacionalmente ineficientes y no son una buena elección para encriptar cantidades de datos grandes.

Los diferentes algoritmos de clave pública pueden clasificarse dependiendo del problema en que están basados y en el que radica su seguridad. Con mucha diferencia, los más comunes son:

• La factorización de enteros, en la que se basa el criptosistema RSA [28].

• El problema del logaritmo discreto, en el que se basan algoritmos como el de Diffie-Hellman [29], ElGamal [30] o DSA [31].

• El problema del logaritmo discreto sobre curvas elípticas.

Desde el punto de vista del hardware, el criptosistema RSA es, con diferencia, el más ampliamente estudiado debido en parte también a que ha sido el de mayor aceptación a nivel comercial e industrial. Pese a ello, en los últimos tiempos todas las investigaciones se vienen centrando en los criptosistemas basado en curvas elípticas (ECC) y ya existe una clara tendencia a la utilización de la tecnología ECC como base criptográfica.

Establezcamos una comparativa entre ambos que nos permita seleccionar la mejor opción.

1.3.2 COMPARACIÓN RSA-ECC

Cuando comparamos diferentes sistemas criptográficos de clave pública no debemos centrarnos únicamente en un aspecto relevante como pueda ser su tamaño o velocidad, sino que debemos tener en cuenta todos los factores que lo caracterizan. Estos factores son:

• Seguridad. Que nos indicará en qué está basada su seguridad, durante cuánto tiempo ha tenido un amplio uso y cuánto ha sido estudiada esta seguridad.

• Eficiencia. Que nos dará información de cuáles son las necesidades de cálculo necesarias para llevar a cabo las transformaciones de clave pública y privada.

• Requisitos de espacio. Que nos indicará cuántos bits se necesitan para almacenar los pares de claves y demás parámetros asociados.

CAPÍTULO 1

13

En este capítulo, en primer lugar, comentaremos la teoría en la que se basa el sistema RSA y a continuación lo compararemos con los basados en curvas elípticas en estos términos de seguridad, eficiencia y requisitos de espacio.

En cualquier caso, hemos de tener en cuenta que las características funcionales del criptosistemas RSA y los basados en ECC han sido comparadas en diferentes trabajos que, en mayor o menor grado, han mostrado siempre las ventajas que nos ofrecen los ECC sobre RSA [32].

CRIPTOSISTEMA RSA

El criptosistema RSA fue introducido en 1977 por Rivest, Shamir y Adleman [28] y fue la primera materialización del modelo abstracto de Diffie y Hellman para criptografía de clave pública [25].

El algoritmo RSA es el más popular de toda la familia de criptosistemas basados en la factorización de enteros, en los que su fortaleza yace en la dificultad matemática de factorizar enteros grandes. El uso de este tipo de números hace que, en ausencia de métodos matemáticos o técnicas computacionales mejores o más rápidas, el método de factorización mediante fuerza bruta sea impracticable [33].

Por tanto, el nivel de seguridad ofrecido por RSA depende de la dificultad matemática inherente a la factorización de números enteros grandes, mientras que la velocidad de estos sistemas dependerá de los tiempos requeridos para la realización de la exponenciación modular.

El criptosistema RSA sigue siendo el método de clave pública de mayor utilización. Puesto que la multiplicación de enteros en módulo n es relativamente compleja de implementar y la exponenciación requiere multiplicaciones sucesivas, el RSA no puede alcanzar las velocidades que nos ofrecen los sistemas de clave privada. Por supuesto, esto es cierto no solo para el RSA, sino para cualquier otro sistema de clave pública. El encriptado RSA y la verificación de firma puede incrementar significativamente su velocidad mediante la selección de exponentes b pequeños. Valores típicos utilizados en la práctica son b = 3 y b = 216 + 1. Las implementaciones RSA más rápidas en hardware pueden encriptar con tasas del orden de 7 Mbits/s trabajando con claves de 512 bits [34].


14

EL PROBLEMA DE LA FACTORIZACIÓN DE ENTEROS

Como comentábamos antes, el criptosistema RSA está basado en el problema de la factorización de enteros. Para su establecimiento, un usuario elige dos números primos grandes p y q y calcula su producto n = pq. El grupo utilizados es *

nG = , el grupo multiplicativo de enteros en módulo n. El orden de G será 𝜙𝜙(𝑛𝑛) = (𝑝𝑝 − 1)(𝑞𝑞 − 1), donde 𝜙𝜙 representa la función phi de Euler y que podrá ser calculado por el usuario. Su clave pública será el par de enteros (n, b).

Podemos comprobar que el problema de calcular 𝜙𝜙(𝑛𝑛) conociendo solamente n es computacionalmente equivalente al problema de factorizarlo. Además, no existe ningún algoritmo eficiente capaz de calcular sus b raíces en *

n sin conocer previamente p y q. Por tanto, podemos afirmar que romper el criptosistema RSA es equivalente al problema de factorizar n.

ALGORITMO DE ENCRIPTACIÓN RSA

Definamos el sistema de encriptación RSA. Sea n = pq, donde p y q son primos. Definamos:

𝒦𝒦 = �(𝑛𝑛, 𝑝𝑝, 𝑞𝑞, 𝑎𝑎, 𝑏𝑏) ∶ 𝑛𝑛 = 𝑝𝑝𝑞𝑞, con 𝑝𝑝 y 𝑞𝑞 primos y 𝑎𝑎𝑏𝑏 ≡ 1 �mod�𝜙𝜙(𝑛𝑛)��

para 𝒦𝒦 = (𝑛𝑛, 𝑝𝑝, 𝑞𝑞, 𝑎𝑎, 𝑏𝑏) tendremos:

( ) mod bKe x x n= (1.1)

y

( ) mod aKd y y n= (1.2)

con (𝑥𝑥,𝑦𝑦 ∈ ℤ𝑛𝑛). Los valores de n y b son públicos, mientras que 𝑎𝑎 es secreto.

FIRMA RSA

Definamos ahora el algoritmo de firma RSA. Sea n = pq, donde p y q son primos y definamos:

𝒦𝒦 = �(𝑛𝑛, 𝑝𝑝, 𝑞𝑞, 𝑎𝑎, 𝑏𝑏) ∶ 𝑛𝑛 = 𝑝𝑝𝑞𝑞, con 𝑝𝑝 y 𝑞𝑞 primos y 𝑎𝑎𝑏𝑏 ≡ 1 �mod�𝜙𝜙(𝑛𝑛)��

CAPÍTULO 1

15

Los valores de n y b son públicos, mientras que 𝑎𝑎 es secreto.

Para 𝒦𝒦 = (𝑛𝑛, 𝑝𝑝, 𝑞𝑞,𝑎𝑎, 𝑏𝑏) estableceremos:

( )sig mod aK x x n= (1.3)

y

( )ver válido (mod )bK x x y n= ⇔ ≡ (1.4)

con ( , )∈nx y .

SEGURIDAD

Describamos brevemente las formas de ataque más comunes sobre ambos esquemas.

ATAQUES SOBRE RSA

Los ataques sobre RSA están basados en la resolución del problema de la factorización de enteros.

Existen dos tipos de algoritmos: los de propósito general y los específicos. Los algoritmos específicos tratan de explotar las características especiales del sistema que se está considerando, cómo es el número n a factorizar.

En los algoritmos de propósito general, el tiempo de factorización depende solamente del tamaño del entero a factorizar. Previamente al desarrollo del criptosistema RSA, el mejor algoritmo de factorización de propósito general era el de fracciones continuas [35], que nos permite factorizar números decimales de hasta 40 dígitos (133 bits). Este algoritmo está basado en la idea de utilizar un factor base de primos y generar un conjunto de ecuaciones lineales cuya solución nos lleve finalmente a la factorización. Esta es la misma idea en la que se basan los algoritmos más utilizados hoy por hoy: la criba cuadrática y el algoritmo general de criba del cuerpo de números [35]. Ambos algoritmos pueden ser fácilmente paralelizados para permitir la factorización en redes distribuidas de estaciones de trabajo.

La tabla 1.1 nos muestra que un número de 512 bits solamente nos ofrece una seguridad marginal si utilizamos RSA. Para mantener cierta seguridad a medio plazo deberemos utilizar claves de al menos 1024 bits.


16

Los algoritmos de propósito específico tratan de aprovechar determinadas características particulares de los enteros a factorizar. Probablemente el más sencillo sea el de división por tentativa. Un algoritmo sencillo de factorización para n = p · q siempre que (p – 1) o (q – 1) posea factores primos pequeños, es el denominado método de curva elíptica de Lenstra. Su tiempo de ejecución dependerá del tamaño de los factores primos de n puesto que el algoritmo tiende a encontrar en primer lugar los más pequeños.

Tabla 1.1: Capacidad de cálculo requerida para factorizar enteros utilizando el algoritmo general de criba del cuerpo de números.

Tamaño del entero a factorizar (en bits) MIPS año 512 3·104

768 2·108

1024 3·1011 1280 1014 1536 3·1016 2048 3·1020

ATAQUES SOBRE CRIPTOSISTEMAS BASADOS EN CURVAS ELÍPTICAS

Los ataques sobre criptosistemas basados en curvas elípticas están basados en la resolución del problema del logaritmo discreto sobre curvas elípticas (ECPLD). Los métodos actuales [36] dependen de la existencia de un grupo abeliano finito y, por tanto, pueden aplicarse sobre curvas elípticas los mismos métodos que al problema del logaritmo discreto. Estos métodos suelen ser mucho más lentos debido a la complejidad añadida por las operaciones a realizar sobre los puntos de la curva con que se esté trabajando.

Si E es una curva elíptica definida sobre un cuerpo finito binario y P y Q son puntos pertenecientes a la curva, los principales ataques que podemos encontrar son los que describiremos a continuación.

ALGORITMO RHO DE POLLARD

Está basado en el algoritmo baby-step giant-step y tiene un tiempo de ejecución de �𝜋𝜋𝜋𝜋/2 pasos, donde un paso se corresponde con la suma de dos

CAPÍTULO 1

17

puntos de la curva y r es el orden del punto P. La tabla 1.2 muestra la capacidad de computación necesaria para calcular los logaritmos sobre la curva elíptica con el método Rho de Pollard.

Tabla 1.2: Potencia de cálculo requerida para la obtención del logaritmo elíptico con el método Rho de Pollard.

Tamaño del cuerpo (bits)

Tamaño de r (bits) �𝜋𝜋𝜋𝜋/2 MIPS años

163 160 280 9,6 · 1011

191 186 293 7,9 · 1015 239 234 2117 1,6 · 1023 359 354 2177 1,5 · 1041 431 426 2213 1,0 · 1052

ALGORITMO DE POHLIG-HELLMAN

Este algoritmo [37] aprovecha la factorización de r reduciendo el problema de la obtención de la clave privada a al problema de recuperar el módulo de cada uno de los factores primos de r; posteriormente, a podrá recuperarse mediante el teorema chino del resto. Por tanto, para construir una situación con complejidad elevada en el ECDLP, deberemos elegir una curva elíptica cuyo orden sea divisible por un primo r de gran tamaño, como por ejemplo r > 2160. Preferiblemente el orden debe ser un primo o semiprimo (es decir, un primo grande que sea r veces un entero h).

MÉTODO INDEX-CALCULUS

A diferencia de otros grupos utilizados en criptografía, el grupo de las curvas elípticas no presenta unos niveles de suavidad aceptables; es decir, no existe un conjunto reducido de elementos a partir de los cuales otro elemento cualquiera pueda expresarse fácilmente mediante un algoritmo simple. Debido a esto, el método Index-Calculus no funciona para el ECDPL. Sin embargo, en 1991, Menezes, Okamoto y Vanstone (MOV) demostraron que el ECDPL puede reducirse al problema del logaritmo discreto general (DPL) como una extensión de 𝔽𝔽𝑞𝑞 , donde sí puede aplicarse el método. Sin embargo, el algoritmo de reducción MOV [38] solo es efectivo para unos casos particulares de curvas, conocidas como curvas supersingulares.


18

CURVAS SUSCEPTIBLES DE ATAQUES PARTICULARES

Existen una serie de casos relevantes de ataques sobre determinados tipos de curvas, que comentaremos ahora conjuntamente con la forma de evitarlos.

Curvas supersingulares

Diremos que la curva [GF(q)]E es supersingular si es un cuerpo de característica dos y posee un j-invariante igual a cero. Por otra parte, si

[GF(q)]E es un cuerpo de característica impar, la curva es supersingular si q = 2 ó 3 y j(E)=0; o 𝑞𝑞 ≥ 5 y la traza de Frobenius [36] satisface que t = 0.

Las curvas supersingulares están expresamente prohibidas por el estándar IEEE P1363 así como por otros estándares desarrollados para las curvas elípticas como son el ANSI X9.62 y el ANSI X9.63.

Menezes, Okamoto y Vanstone [38] y Frey y Ruck [39] demostraron cómo, en determinados casos, el ECDPL en una curva elíptica E definida en un cuerpo finito 𝔽𝔽𝑞𝑞 puede reducirse al DPL en una extensión del cuerpo original y, por tanto, se puede aplicar el algoritmo index-calculus. El algoritmo de reducción se puede aplicar solo si el exponente del cuerpo de extensión es pequeño, que no suele ser el caso de la mayoría de las curvas elípticas. Para asegurar que este algoritmo de reducción no es aplicable a una curva particular, solo necesitaremos comprobar que r (el orden del punto P) no es divisor de qB – 1 para valores de pequeños de B. Por tanto el DLP en 𝔽𝔽𝑞𝑞

resulta intratable (2

20001log

≤ ≤Bq

es suficiente). Esto se conoce con la

condición de MOV.

Curvas anómalas

De forma independiente Smart [40] y Satoh y Araki [41] demostraron que el ECDPL para el caso especial de curvas elípticas anómalas es fácil de resolver. Una curva elíptica anómala es una curva elíptica sobre 𝔽𝔽𝑞𝑞 que posee exactamente q puntos. Este ataque no es extensible al resto de curvas elípticas y, consecuentemente, bastará con comprobar que el número de puntos de la curva no coincide con el número de elementos del cuerpo sobre

CAPÍTULO 1

19

el que se está trabajando. Este tipo de curvas está expresamente prohibido en todos los estándares de curvas elípticas.

Si existe o no un algoritmo de tiempo subexponencial para el ECPLD es una cuestión incierta y de gran relevancia dentro de la seguridad de los ECC y es muy improbable que se pueda demostrar que no existe un algoritmo de este tipo en los próximos años. Sin embargo, se han venido realizando multitud de trabajos sobre el DLP en los últimos 20 años y más específicamente sobre el ECDLP en los últimos 15 [36]. A día de hoy, no se ha encontrado un algoritmo de tiempo subexponencial para el ECDPL y, posiblemente, ni siquiera exista.

Menezes y Jurisic [35] compararon el tiempo necesario para romper un ECC con el tiempo necesario para romper un RSA compuesto por varios módulos utilizando el mejor algoritmo de propósito general conocido. Los valores están expresados en MIPS año, que representan el tiempo de cálculo durante un año de una máquina capaz de ejecutar un millón de instrucciones por segundo. Los resultados se muestran en la tabla 1.3. Hoy por hoy se acepta como seguro un resultado del orden de 1012 MIPS año.

Tabla 1.3: Comparación entre la fortaleza de las clave según su tamaño

Tiempo de ruptura

(MIPS año)

Tamaño de clave RSA (en

bits)

Tamaño de clave ECC (en

bits)

Relación entre claves RSA/ECC

104 512 106 5:1 108 768 132 6:1 1011 1024 160 7:1 1020 2048 210 10:1 1078 21000 600 35:1

En esta tabla comprobamos que para alcanzar una seguridad razonable RSA necesita emplear del orden de 1024 bits, mientras que en un ECC 160 bits son suficientes. Encontramos, por tanto, que un ECC requiere un módulo mucho menor que el RSA y que esta diferencia crece según lo va haciendo el tamaño de la clave. Por ejemplo, el ECC con una clave de 250 bits es mucho más seguro que un RSA de 2000 bits.

Otra forma de observar esta seguridad es comparar las fortalezas de las claves de RSA y de un ECC para aplicaciones con smart cards. Puesto que un ECC requiere tamaños de clave mucho más reducidos, será capaz de ofrecer


20

la seguridad requerida sin necesidad de realizar cambios significativos en los recursos disponibles.

EFICIENCIA

Tanto en un criptosistema RSA como uno basado en curvas elípticas se pueden realizar una disminución en el gasto computacional necesario para su funcionamiento. En RSA puede emplearse un exponente reducido (aunque si bien representa un ahorro, estaremos incurriendo en ciertos riesgos de seguridad) para aumentar la velocidad en la verificación de firmas y encriptación. En los ECC, una gran parte de la generación de firmas y las transformaciones de encriptación puede ser precalculadas. También pueden emplearse varias bases especiales en el cuerpo finito 𝔽𝔽2𝑚𝑚 que nos permitirán realizar la aritmética modular implicada de una forma mucho más rápida. Las implementaciones realizadas de ambos sistemas nos muestran que un ECC es en torno a 12 veces más rápido que el RSA [37]. El uso de exponentes pequeños puede hacer que los tiempos de encriptación y la verificación de firmas sean comparables con un ECC, pero no ocurre lo mismo con los tiempos de desencriptación y generación de firmas.

REQUISITOS DE ESPACIO

Los criptosistemas basados en curvas elípticas tienen el potencial de proporcionar la misma seguridad que los sistemas de clave pública existentes, pero con menor tamaño de claves. El hecho de trabajar con menor tamaño de clave es un factor que puede resultar crucial en determinadas aplicaciones, como pueden ser aquellas que tengan restricciones de espacio. Por ejemplo, el procesador aritmético de una smart card está restringido en tamaño. Un chip diseñado para realizar una multiplicación modular de 512 bits emplea alrededor de 50000 transistores, mientras que un chip diseñado para realizar operaciones aritméticas en 593GF(2 ) utiliza alrededor de 100000 transistores [42]. Aun con la tecnología actual, estos dispositivos son demasiado grandes para ser introducidos en una smart card. Como comparación diremos que un chip diseñado para operar en GF(2 )m , con valores de m en torno a 200 requiere menos de 15000 transistores. Otra ventaja que encontramos en el uso de curvas elípticas radica en que cada

CAPÍTULO 1

21

usuario puede seleccionar una curva E diferente aunque todos ellos utilicen el mismo cuerpo K.

Tabla 1.4: Requisitos de espacio

La tabla 1.4 compara el tamaño de los parámetros del sistema y el par de claves seleccionadas, evidenciando que es mucho menor en un ECC de 160 bits que en un RSA de 1024 bits [35]. Ambos sistemas presentan similares necesidades de ancho de banda cuando se utilizan para encriptar o firmar mensajes grandes, pero no ocurre lo mismo cuando se su tamaño es pequeño. Hemos de tener en cuenta que frecuentemente la criptografía de clave pública se utiliza con mensajes cortos como, por ejemplo, para transmitir las claves de una sesión para un sistema de clave privada. Por este motivo, hemos tomado como referencia la firma de un mensaje de 2000 bits y el encriptado de un mensaje de 100 bits [35]. El algoritmo de encriptación utilizado es una variante de ElGamal. Los resultados son los que se muestran en las tablas 1.5 y 1.6.

Tabla 1.5: Tamaños de firma para un mensaje de 2000 bits

Tabla 1.6: Tamaño de un mensaje encriptado de 100 bits

Parámetros del Sistema (bits)

Clave Pública (bits)

Clave Privada (bits)

RSA 1024 bits - 1088 2048 ECC 160 bits 481 161 160

Tamaño de firma (bits)

RSA 1024 bits 1024 ECC 160 bits 320

Tamaño del mensaje (bits)

RSA 1024 bits 1024 ECC 160 bits 321


22

En esta comparación observamos que el ECC ofrece un considerable ahorro de ancho de banda frente al RSA cuando se utiliza para mensajes cortos.

En resumen, los ECC nos ofrecen una mayor eficiencia tanto si lo miramos desde el punto de los sistemas de factorización de enteros, en términos de necesidades computacionales, tamaños de clave y ancho de banda. En una implementación esto significa mayor velocidad, menor consumo y reducción del tamaño del código o hardware a utilizar. Aunque el sistema RSA es el de mayor aceptación y utilización, ya en los últimos tiempos todas las investigaciones se han centrado en los ECC y ya existe una clara tendencia a la utilización de la tecnología ECC como base criptográfica.

1.4 IDENTIFICACIÓN DEL PROBLEMA

Como se puede deducir del apartado anterior, todos los metodos y algoritmos utilizados para la implementacion de la criptografıa de clave publica presentan sus ventajas e inconvenientes. Unos consiguen la gran flexibilidad que proporciona el software a costa de ofrecer una menor velocidad, mientras que los otros mejoran esta velocidad a base de trabajar generalmente en un escenario muy especıfico o a costa de unas cantidades de espacio notables.

En este sentido, sería deseable llegar a una implementacion hardware que ofrezca posibilidades de configuracion de forma sencilla conjuntamente con unos requisitos de espacio ajustados. Estas posibles optimizaciones son algunos de las razones que motivan tanto la presente tesis como otros trabajos sobre el estudio de arquitecturas hardware eficiente.

Po otra parte, la mayoría de los trabajos se centran en un campo y un tamaño de clave fijos y la modificación de estos valores implica en el mejor de los casos volver a implementar el sistema y siempre trabajar en un campo único. En los que el campo no es fijo, se opera en un número de ellos concreto sin que se pueda extender o modificar más allá de los especificados. Todo esto les puede conducir a obtener unos buenos resultados, pero sin disponer de una flexibilidad que permita presentarlos como de uso genérico. Sería deseable poder disponer de un sistema que no solo nos permitiese elegir las condiciones de operación, sino que además éstas no se tengan que adoptar de forma obligatoria entre unos valores muy concretos.

CAPÍTULO 1

23

De forma sintetizada podemos definir el problema a tratar en la presente tesis como la necesidad de disponer de algoritmos y estructuras que permitan ser implementados en dispositivos hardware de forma eficiente y que, al mismo tiempo, sean capaces de operar en cualquier campo de trabajo sin necesidad de rediseño o adaptación posterior. Es decir, que se puedan acomodar a cualquier necesidad de trabajo sin ser modificados y sin que por ello el volumen de recursos consumidos haga que su uso sea desaconsejable en un dispositivo de tamaño reducido.

También sería deseable analizar, por una parte, sus necesidades energéticas, comprobando que su consumo no es excesivo y por otra parte su robustez frente a los posibles ataques.

1.5 OBJETIVOS Y PROPUESTA DE SOLUCIÓN

Una de las operaciones básicas dentro de la criptografía de curvas elípticas es la multiplicación escalar, en la que se requiere un gran número de multiplicaciones y de inversiones de puntos en un cuerpo finito preestablecido. Ambas operaciones son las que más recursos consumen con diferencia. Sin embargo, si bien la inversión suele requerir más espacio y tiempo que la multiplicación, es posible realizar una única inversión en una multiplicación escalar completa. Esto nos conduce a que sea imperativo optimizar el algoritmo de multiplicación que se emplee.

Teniendo en cuenta estos condicionantes, en este trabajo se propone un modelo de un sistema criptoprocesador que sea capaz de operar en un entorno con recursos hardware restringidos. Para conseguirlo se plantean los siguientes objetivos:

• Analizar los principales algoritmos que operan sobre cuerpos finitos integrándolos en un microprocesador de pequeñas dimensiones y comprobar sus posibilidades.

• Desarrollar una propuesta de algoritmo de multiplicación que se adecue a las necesidades impuestas y nos proporcione una buena relación entre los recursos consumidos y el tiempo de respuesta proporcionado. Este algoritmo debe poder adaptarse a cualquier campo de trabajo, sin necesidad de hacer consideraciones posteriores o depender de forma específica del tamaño palabra prestablecido.


24

• Integrar el multiplicador propuesto dentro de un sistema criptoprocesador que se pueda adaptar para operar sobre los cuerpos finitos con tamaños de clave variable.

Para comprobar la efectividad de la propuesta, se plantea la descripción del sistema sobre VHDL y su implementación sobre un FPGA y se proporcionarán los resultados obtenidos.

25

CAPÍTULO 2

FUNDAMENTOS TEÓRICOS En el trabajo descrito en esta tesis se abordan diversos aspectos de la implementación de algoritmos criptográficos que requieren una breve introducción matemática que nos ayude a definir adecuadamente los términos y conceptos que se utilizan ampliamente en los capítulos siguientes. Se ha tratado de discutir y definir sólo aquellos temas que son absolutamente necesarios, y se remite al lector a cualquiera de la multitud de excelentes referencias sobre teoría de números y criptografía (por ejemplo, [43], [25], [36]) como material adicional cuyo contenido se considera más allá del objetivo de este capítulo.

2.1 CUERPOS FINITOS Como paso previo a la definición de cuerpo finito debemos definir en qué consiste un grupo, puesto que ambos constituyen la base de cualquier criptosistema basado en curvas elípticas.

Un grupo es un conjunto de elementos G relacionados mediante una operación ♦. ,♦G será un grupo si y solo si se cumplen las siguientes

condiciones:

• El resultado de la operación ♦ aplicada a dos elementos de G es también un elemento de G:

FUNDAMENTOS TEÓRICOS

26

1 2 1 2 3, : g g G g g g∀ ∈ =♦ , con 3∈g G

• La operación ♦ es asociativa: 1 2 1 2 3, : g g G g g g∀ ∈ =♦

• Existe un elemento neutro, que si lo representamos por e: 1 1 1 1 : e eg G g g g=♦ ♦∀ ∈ =

• Todo elemento 1g G∈ tendrá un elemento inverso, que si lo representamos por 2g cumplirá que:

1 1 2 2 1 : g G g g g g e♦ ♦∀ ∈ = =

Además, diremos que el grupo A es abeliano si cumple que la operación ♦ es conmutativa: 1 1 2 2 1 : g G g g g g∀ ∈ =♦ ♦

Cuando la operación ♦ se escribe como +, el inverso de g1 se representa como –g1 y se emplea el 0 como elemento neutro. En este caso, el grupo se denomina grupo aditivo. Cuando se emplea · como operación de grupo, 1

1g−

será el inverso de g1 y el elemento neutro será 1. Ahora estamos ante un grupo multiplicativo.

Un cuerpo es un conjunto de elementos F relacionados mediante dos operaciones que representaremos mediante (+, ·). , ,·F + será un cuerpo si

y solo si se cumplen las siguientes condiciones:

• ,F + es grupo aditivo abeliano.

• { }\ 0 ,·F es un grupo multiplicativo abeliano.

• La operación · es distributiva frente a la operación +:

( )1 2 3 1 2 3 1 2 1 3, , : · · · f f f F f f f f f f f∀ ∈ + = +

Si un cuerpo tiene un número finito de elementos se denomina cuerpo finito o campo de Galois y se suele representar mediante GF. El número de elementos de un cuerpo finito es lo que denominaremos orden del cuerpo y es siempre una potencia de un número primo. Para aplicaciones criptográficas se emplean principalmente dos cuerpos:

• Cuerpos en los que los elementos son enteros y su orden es primo, representados por GF(p).

CAPÍTULO 2

27

• Cuerpos cuyos elementos pueden representarse mediante un vector de m bits y su orden es una potencia de dos. Los referiremos como GF(2m).

Veamos ahora estos cuerpos.

2.1.1 EL CUERPO FINITO GF(P)

El cuerpo GF(p) estará compuesto por los elementos {0, 1, 2, 3, …, p–1} y las operaciones se realizan en módulo p:

Suma:

Si ( )1 2 1 2, GF : f f p f f r∈ + =

donde r será simplemente la suma de dos enteros. Si esta fuera mayor que p, a continuación restaríamos p.

Resta:

Si ( )1 2 1 2, GF : f f p f f s∈ − =

donde s es la resta de dos enteros. Si el resultado de la resta fuera negativo, sumaríamos p. Esta operación se denomina resta en módulo p.

Tabla 2.1: Algoritmo de suma en GF(p)

Entrada: ( )1 2, GF∈f f p

Salida: 1 2 mod ≡ +r f f p 1 2 ← +r f f if ≥r p then ← −r r p endif Return (r)


28

Multiplicación:

Si ( )1 2 1 2, GF : ·f f p f f t∈ =

donde t es el resto de dividir 1 2·f f entre p, siendo 0 1≤ ≤ −t p . Esta operación se denomina multiplicación en módulo p.

Evidentemente, la suma en GF(p) es computacionalmente mucho más simple que la multiplicación. Esto es lo que ha conducido a que la mayoría de los esfuerzos de los investigadores se centren en la optimización de los algoritmos de multiplicación.

Tabla 2.3: Algoritmo de multiplicación en GF(p)


Salida: 1 2· mod ≡t f f p 1 2· ←t f f while ≥t p do: ← −t t p Return (t)

Tabla 2.2: Algoritmo de resta en GF(p)


Salida: 1 2 mod ≡ −s f f p 1 2 ← −s f f

if 0 ≤s then ← +s s p endif Return (s)

CAPÍTULO 2

29

2.1.2 EL CUERPO FINITO GF(2m)

El cuerpo GF(2m) es una extensión del cuerpo GF(2), denominado cuerpo

binario finito, en el que cada elemento de GF(2m) puede representarse mediante un vector de m elementos {𝛼𝛼0,𝛼𝛼1,𝛼𝛼2, … ,𝛼𝛼𝑚𝑚−1} en GF(2). Para cada elemento GF(2 )∈ ma podemos afirmar que:

1

0

donde {0,1} α−

=

= ∈∑m

i i ii

a a a (2.1)

El vector 0 1, 1{ , , , }α α α −… m se denomina base de GF(2m) sobre GF(2) y

podemos representar a como un vector binario 0 1, 1{ , , , }−… ma a a . Las bases

más comunes de GF(2m) sobre GF(2) son la base polinomial, la base normal y la dual.

BASE POLINOMIAL

Sea ( )1

0

−

=

= +∑m

m ii

i

f x x f x , donde {0,1}∈if . ( )f x es un polinomio

irreducible de grado m sobre GF(2) llamado polinomio de reducción. Para cada polinomio de reducción, existe una representación en base polinomial en la que cada elemento de GF(2m) se corresponde con un polinomio binario de grado menor que m. Es decir, para cada elemento GF(2 )∈ ma , existen m números {0,1}∈ia tales que:

11 1 0

mma a x a x a−−= +…+ + (2.2)

El elemento 𝑎𝑎 ∈ GF(2𝑚𝑚) normalmente se representa por el vector (am-1 … a1a0), de longitud m. Si utilizamos un polinomio de reducción 𝑓𝑓(𝑥𝑥), podemos definir las siguientes operaciones:

Suma:

Si a = am-1 … a1a0 y b = bm-1 … b1b0: a + b = c

donde c = (cm-1 … c1c0), con ci = (ai + bi) mod 2. Es decir, la suma se corresponde con la operación OR Exclusiva de cada par de bits de a y b que ocupan posiciones homónimas.


30

Multiplicación:

Si a = am-1 … a1a0 y b = bm-1 … b1b0: a · b = c

donde c = (cm-1 … c1c0), siendo ( )1

0

−

=

=∑m

ii

i

c x c x el resto de dividir

1 1

0 0

·− −

= =

∑ ∑m m

i ii i

i i

a x b x entre el polinomio de reducción 𝑓𝑓(𝑥𝑥).

Como polinomio de reducción se suele elegir un trinomio irreducible de la forma 1+ +m kx x . En el caso de no existir trinomios irreducibles, se recurre a un pentanomio del tipo 3 2 1 1+ + + +k k kmx x x x .

BASE NORMAL

Una base normal de GF(2m) sobre GF(2) es una base de la forma

{ }12 2, , , β β β−

…m donde GF(2 )β ∈ m . Esta base siempre existe y, por tanto,

todo elemento ( )GF 2∈ ma puede escribirse como 1

2

0

β−

=

=∑i

m

ii

a a , donde

{0,1}∈ia . El elemento GF(2 )∈ ma normalmente se representa por el vector (a0a1… am-1), de longitud m.

La representación de GF(2m) en una base normal tiene la ventaja de que el cálculo del cuadrado de un elemento se reduce a un simple desplazamiento cíclico de los elementos del vector. Sin embargo, la multiplicación resulta ser la operación más compleja. Afortunadamente, para el tipo particular de las denominadas Bases Normales Gaussianas (GNB), las operaciones aritméticas son mucho más simples. El tipo T de una Base Normal Gaussiana es un entero positivo que mide la complejidad de la multiplicación con respecto a la base: cuanto menor sea, más rápido se realizará el producto.

La existencia de una GNB ha sido caracterizada en [44] y en [45]. En particular, existe una GNB siempre que m no sea divisible por 8. Además, si m es divisible por 8, existirá un tipo T para la GNB en GF(2m) si y solo si p = Tm + 1 es primo y el mcd(Tm/k,m) = 1, donde k es el orden multiplicativo de 2 en módulo p.

CAPÍTULO 2

31

Las operaciones sobre GF(2m) utilizando una Base Normal Gaussiana de tipo T quedan definidas de la siguiente forma:

Suma:

Si a = a0a1 … am-1 y b = b0b1 … bm-1: a + b = c

donde c = (c0c1 … cm-1), con ci = (ai + bi) mod 2. Es decir, la suma se corresponde con la operación OR Exclusiva de cada par de bits de a y b que ocupan posiciones homónimas.

Elevación al cuadrado:

Puesto que la elevación al cuadrado es una operación lineal en GF(2m),

( )

121 1 1

2 2 2 21

0 0 0

1 0 1 2

mod β β β+

− − −

−= = =

− −

== = =

= …

∑ ∑ ∑i i i

m m m

i i ii i i

m m

a a a a m

a a a a

(2.3)

Por consiguiente, la elevación al cuadrado consiste en la simple rotación de la representación del vector.

Multiplicación:

Sea p = Tm +1 y sea GF(∈u p ) un elemento de orden T. Definiremos la secuencia F(1), F(2), …, F(p-1) como:

( ) ( )2 mod para 0 1 y (0 1)= ≤ ≤ − ≤ ≤ −i jF u p i i m j T

Para cada l, con (0 ≤ 𝑙𝑙 ≤ 𝑚𝑚 − 1), definimos Al y Bl como:

( ) ( )

2

11

−

+ + − +=

=∑p

l F k l F p k lk

A a b (2.4)

/2

1 11 11 2 2

( )+ − + −+ + − + + −=

= + +∑m

l k l m m k l lk l k lk

B a b a b A (2.5)

Si a = a0a1 … am-1 y b = b0b1 … bm-1: a · b = c


32

c = (c0c1 … cm-1), con

=

ll

l

A si T es parc

B si T es impar para valores de l tales que

( )0 1≤ ≤ −l m y los índices están reducidos a módulo m.

En [46] podemos encontrar un estudio completo sobre algoritmos sobre campos finitos utilizando bases normales en GF(2m).

2.1.3 ARITMÉTICA EN EL CAMPO FINITO GF(2m) UTILIZANDO BASE POLINOMIAL

En este punto describiremos varios algoritmos a nivel de bit que nos permitirán realizar cálculos en GF(2m) utilizando base polinomial para su representación. Estos algoritmos pueden modificarse fácilmente para obtener su estructura a nivel de palabra, que nos permitirá su rápida implementación en software.

Suma: La suma en GF(2m) se reduce a la suma de dos vectores en GF(2). Es decir, a la suma de los bits que ocupan la misma posición en módulo 2.

Reducción modular: La definición de la multiplicación o el cuadrado polinomial implica que el resultado ha de reducirse a módulo m, siendo m el grado del polinomio irreducible empleado. Esta operación de reducción es particularmente eficiente cuando el polinomio irreducible empleado ( )f x es

Tabla 2.4: Algoritmo para la suma en GF(2m)

Entrada: 1 1 0 1 1 0( , , , ) y ( , , , , )− −= … = …m m ma a a a b b b b b Salida: 1 1 0( , , , )−= + = …mc a b c c c

1

2 2

0

−

=

←∑m

ii

i

t a x

for 0 to 1= −i m ( )mod2← +i i ic a b Return (c)

CAPÍTULO 2

33

un trinomio o un pentanomio. El siguiente algoritmo nos permite obtener ( ) mod ( )a x f x reduciendo el grado de ( )a x hasta un valor inferior a m.

Cuadrado: Esta operación puede calcularse de una forma muy eficiente si tenemos en cuenta que el cuadrado de un polinomio a dado es:

21 12 2 2

0 0

( )− −

= =

= = ∑ ∑m m

i ii i

i i

a x a x a x (2.6)

Que nos conduce al algoritmo de la tabla 3.6:

Multiplicación: La técnica básica de llevar a cabo una multiplicación es mediante el método de desplazamiento y sumas. Es similar al método binario para la exponenciación, en el que el cuadrado y la multiplicación se

Tabla 2.6: Algoritmo para la obtención del cuadrado en GF(2m)

Entrada: 1 1 0 1 1 0( , , , ) ( , , , , )m m ma a a a y f f f f f− −= … = …

Salida: 2 mod c a f=

1

2

0

−

=

←∑m

ii

i

t a x

mod ←c t f (mediante el algoritmo de la taba 3.5) Return (c)

Tabla 2.5: Algoritmo de reducción modular en GF(2m)

Entrada: 2 2 1 0 1 1 0( , , , ) ( , , , , )− −= … = …m m ma a a a y f f f f f Salida: mod =c a f for 2 2 downto i m m= − for 0 to 1 = −j m

if 0 then j i m j i m j if a a a− + − +≠ ← +

Return ( 1 1 0( , , , )mc a a a a−← = … )


34

reemplazan respectivamente por la multiplicación de un elemento x del campo y por la suma. Dado un elemento GF(2 )ma∈ la operación de

desplazamiento a la izquierda ( ) mod ( )xa x f x puede realizarse de la

siguiente forma:

( )( )

1

1 11

1

1 0 11

si 0

mod

si 0

−

− −=

−

− −=

=

=

+ + ≠

∑

∑

mj

j mj

mj

j j mj

a x a

xa f x

a f x f a

(2.7)

los pasos del método de sumas y desplazamientos serán los indicados en el algoritmo de la tabla 2.4.

Este método realiza m – 1 operaciones de desplazamiento a la izquierda y m sumas de media, si bien podemos encontrar en la literatura diferentes técnicas que mejoran la eficiencia de este algoritmo [47], [48], [49].

Inversión: El algoritmo básico para el cálculo del inverso multiplicativo de un elemento es el algoritmo extendido de Euclides. Una descripción a alto nivel de este método es la que se muestra en el algoritmo de la tabla 2.8.

Tabla 2.7: Algoritmo de multiplicación en GF(2m)

Entrada: ( ) ( ) 1 1 0GF 2 , GF 2 ( , , , , )m mm ma b y f f f f f−∈ ∈ = …

Salida: · mod c a b f= ( ) 0c x ← for j = m – 1 downto 0 ( ) ( ) mod ( )c x xc x f x←

if ( ) ( )0 then ( )ja c x c x b x≠ ← +

Return (c)

CAPÍTULO 2

35

La implementación de un operador dedicado que realice la inversión utilizando el método de Euclides es de por sí costosa, además de requerir variables adicionales que requerirán elementos de almacenamiento específicos. Otro método simple de llevar a cabo la inversión es mediante el pequeño teorema de Fermat [26]:

11 (2 1) 1 2 1 2( ) mod ( ) GF(2 )m m ma a a f x a

−− − − −≡ = ∀ ∈ (2.8)

Puesto que 1

2

0

2 2−

−

=

=∑m

m i

i

, una forma de llevar a cabo esta exponenciación

sería mediante la realización sucesiva de multiplicaciones y cuadrados:1 2 11 2 2 2...

ma a a a

−− = ⋅ ⋅ ⋅ , que requerirá un total de (m – 2) multiplicaciones y (m – 1) cuadrados. Aunque la obtención los cuadrados es sencilla al estar trabajando en un cuerpo de característica 2, el elevado número de multiplicaciones hace método resulte excesivamente costoso y ralentizaría en exceso cualquier el sistema.

Tabla 2.8: Algoritmo extendido de Euclides

Entrada: ( ) 1 1 0GF 2 , con 0 ( , , , , )−∈ ≠ = …mm ma a y f f f f f

Salida: 1 mod c a f−=

( )1 21, ( ) 0b x b x← ←

( )1 2( ), ( ) ( )p x a x p x f x← ←

while deg 1( ) 0 do≠p

if deg ( )1 2( ) deg thenp p<

swap p1, p2 y b1, b2

end if 1 2deg( ) deg( )j p p← −

1 1 2 1 1 2, ( ) ( ) ( ) ( ) ( ) ( )j jp p x p b b x bx x x x x x← + ← + end while ( ) ( )1c x b x← Return ( )c x


36

Partiendo del teorema de Fermat, Itoh y Tsujii propusieron un algoritmo [10] que reduce el número de operaciones a realizar. El algoritmo de Itoh y Tsujii calcula el elemento 2m-1 – 1 mediante una reordenación recursiva de las operaciones sobre el cuerpo finito. Hagamos en la ecuación (2.8)

12mkb −= y asumamos que (m – 1) lo podemos expresar de la forma

11 22 2 2 2t tl ll l −+ + + + , por tanto nos quedara transformada en:

( )

1 2

1222

2212

1 1 2 1 1

1 (2 2) (2 1)

22

22

2

2 2 22 2

m m

ll

ltlt

l l l l lt t

a a a

b b b b b

−

−

−

− −

− − −≡ = =

=

(2.9)

Que tendrá una complejidad de (m – 1) cuadrados y ( 1) 2N k hw m= + − −

multiplicaciones, donde 2log ( 1)k m= − es el número de bits y hw(m – 1)

el peso de Hamming de la representación binaria de (m – 1). Esto supone un considerable ahorro en las multiplicaciones a realizar. Su aplicación habitual es mediante la utilización de cadenas aditivas.

Alternativamente al algoritmo de Euclides, disponemos el algoritmo del casi inverso [50] donde para GF(2)∈a se obtiene como resultado un par (b, k)

donde (mod ( )).kba x f x≡ La reducción final que nos proporcionará el

resultado la podemos obtener de la forma 1 mod ( ).ka bx f x− −=

Mientras que el algoritmo extendido de Euclides elimina los bits p1 y p2 de izquierda a derecha (es decir, empezando por el de mayor grado), el algoritmo casi inverso lo hace empezando por los bits de la derecha. Adicionalmente, si sus grados son coincidentes también se eliminarán bits de la izquierda, por lo que es de esperar que el número de iteraciones necesarias para obtener el resultado final sea menor.

CAPÍTULO 2

37

El algoritmo que se muestra en la tabla 2.10 es una modificación del algoritmo de la tabla 2.9 que proporciona directamente el inverso. En lugar de introducir el entero k, el algoritmo realiza el desplazamiento de b1 siempre que p1 acabe en 0. Obsérvese que si b1 no acaba en 0, previamente al desplazamiento se realiza su suma con f, proporcionando finalmente

1 mod ( ).b a f x−=

Tabla 2.9: Algoritmo casi inverso

Entrada: 1 1 0GF(2 , con 0 ( , , , , ))mm ma a y f f f f f−∈ ≠ = …

Salida: GF(2 ) [0,2 1] mod ( )m kb y k m con ba x f x∈ ∈ − = 1 2( ) 1, ( ) 0, 0b x b x k← ← ← 1 2( ) ( ), ( ) ( )p x a x p x f x← ← while (0) 0 do=a

1

1 1 2 2( ) ( ) , ( ) ( ) , 0p x p x x b x b x x k−← ← ← if u = 1 then return (b,k)

else if deg ( )1 2( ) deg thenp p<

swap p1, p2 , swap b1, b2 end if 1 1 2 1 1 2, ( ) ( ) ( ) ( ) ( ) ( )p p p b bx x x x x xb← + = + endif end while


38

2.2 CURVAS ELÍPTICAS La teoría de curvas elípticas ha sido estudiada dentro del álgebra y de la teoría de números de forma intensiva durante los últimos 150 años. Los criptosistemas basados en curvas elípticas fueron presentados por primera vez por N. Koblitz [51] y V. Miller [52] en 1985. Desde entonces se ha desarrollado una vasta literatura referente a este tema.

Las curvas elípticas pueden definirse sobre números reales, complejos y sobre cualquier otro cuerpo. Sin embargo, desde el punto de vista de la criptografía solo son relevantes sobre cuerpos finitos.

Tabla 2.10: Algoritmo casi inverso modificado

Entrada: ( ) 1 1 0GF 2 , con 0 ( , , , , )mm ma a y f f f f f−∈ ≠ = …

Salida: 1 mod ( )a f x− 1 2( ) 1, ( ) 0b x b x← ←

( )1 2( ), ( ) ( )p x a x p x f x← ←

while 1(0) 0 dop =

1

1 1( ) ( )p x p x x−←

if 1 0(0) b = then 11 1( ) ( )b x b x x−←

else 11 1( ) [ ( ) ( )]b x b x f x x−← +

end if

if 1( )p x = 1 then return (b1)

else if deg ( )1 2( ) deg thenp p<

swap 1 2( ), ( )p x p x , swap 1 2( ), ( )b x b x end if 1 1 2 1 1 2( ) ( ) ( ), ( ) ( ) ( )p x p x p x b x b x b x← + = + endif end while

CAPÍTULO 2

39

Una curva sobre un cuerpo finito GF( )q queda definida por un conjunto de puntos ( , )x y que satisfacen la ecuación de la curva, conjuntamente con el punto 𝒪𝒪 , denominado punto al infinito que no satisface la ecuación. Las coordenadas 𝑥𝑥 e 𝑦𝑦 de los puntos de la curva son elementos del cuerpo GF(𝑞𝑞), donde q = pm y p es primo.

Una curva elíptica E sobre un cuerpo 𝕂𝕂 viene definida por la ecuación:

2 3 21 3 2 4 6 con iy a xy a y x a x a x a a+ + = + + + ∈ (2.10)

Si p>3, utilizando transformaciones lineales de las variables, la ecuación de la curva se puede expresar como:

2 3 con ,y x ax b a b= + + ∈ (2.11)

que es la denominada ecuación reducida de Weierstrass, debiendo ser el discriminante del polinomio cúbico en 𝑥𝑥 no nulo, es decir, 3 24 27 0a b+ ≠ , para que la curva no tenga singularidades. Diferentes valores en a y b nos darán lugar a diferentes formas de curva. Si 𝕂𝕂 = ℝ obtendremos curvas como las que se muestran en la figura 2.1.

En el caso p = 2, una curva no supersingular sobre un cuerpo finito queda definida por la ecuación:

2 3 22 6y xy x a x a+ = + + (2.12)

Este tipo de curvas elípticas constituyen un grupo aditivo; es decir, su función básica es la suma. Para ver cómo se puede realizar la suma de dos puntos de una curva, recurriremos a su representación geométrica.

Figura 2.1 – Representación gráfica de una curva sobre números reales


40

Debemos recordar que la presentación negativa de un punto ( ),P x y= la obtendremos como su reflexión sobre el eje 𝑥𝑥, es decir –P será ( ),x y− y que, si el punto P pertenece a la curva, también pertenecerá –P.

Si P y Q son dos puntos de la curva elíptica y 𝑃𝑃 ≠ 𝑄𝑄, la suma de ambos será P + Q = R. Para realizar esta suma, trazaremos una recta que pase por los puntos P y Q y que intersectará con la curva en un tercer punto, que será –R. Si reflejamos el punto –R sobre el eje 𝑥𝑥 obtendremos el punto R que estamos buscando.

R=P+Q

P

-R

Q

Figura 2.2 – Suma de los puntos P y Q de una curva elíptica

P

-R

R=2P

Figura 2.3 – Doblado de un punto P de una curva elíptica

CAPÍTULO 2

41

En el caso de que 𝑃𝑃 = 𝑄𝑄, la suma de ambos será P + P = 2P. Para sumar un punto consigo mismo, dibujaremos la tangente en dicho punto P y que cortará a la curva en –R. Como en el caso anterior, reflejando el punto – R sobre el eje 𝑥𝑥 obtendremos el punto R que estamos buscando.

2.2.1 COORDENADAS AFINES VS. PROYECTIVAS

Una representación alternativa para la curva E consiste en emplear coordenadas proyectivas en lugar de coordenadas afines. En ellas cada punto queda representado por una terna (X, Y, Z), cuya correspondencia con las coordenadas afines dependerá del tipo que utilicemos.

En coordenadas proyectivas estándar, un punto representado por la terna (X, Y, Z), con Z ≠ 0, se corresponde con el punto afín ( / , / )X Z Y Z . El punto al infinito 𝒪𝒪 es (1, 1, 0) y el negativo de (X, Y, Z) es (X, X+Y, Z).

En coordenadas proyectivas jacobianas, un punto representado por la terna (X, Y, Z), con Z ≠ 0, se corresponde con el punto afín 2 3( / , / )X Z Y Z . El punto al infinito 𝒪𝒪 es (0, 1, 0) y el negativo de (X, Y, Z) es (X, X+Y, Z).

En el sistema de coordenadas de López-Dahab, un punto representado por la terna (X, Y, Z), con Z ≠ 0, se corresponde con el punto afín 2( / , / )X Z Y Z . El punto al infinito 𝒪𝒪 es (1, 0, 0) y el negativo de (X, Y, Z) es (X, X+Y, Z).

Tomemos la ecuación (2.12) y hagamos el cambio de variables ( / )y Y Z= y( / )x X Z= . Eliminando denominadores la ecuación se transforma en:

2 2 3 2 2 31 3 2 4 6Y Z a XYZ a YZ X a X Z a xZ a Z+ + = + + + (2.13)

La decisión de utilizar coordenadas afines o proyectivas se basa principalmente en aspectos relativos a la implementación como son la disponibilidad de memoria para almacenar valores temporales así como las prestaciones relativas a los algoritmos utilizados para la implementación de la multiplicación y de la inversión en las operaciones de suma y doblado de puntos de la curva. En coordenadas afines sobre una curva construida sobre el campo GF(2 )m , la suma y el doblado de puntos puede implementarse con una inversión, una multiplicación y un cuadrado si utilización las ecuaciones (2.22) a (2.24) y (2.25) a (2.27), respectivamente. Las expresiones que nos permiten realizar sumas y doblado de puntos en coordenadas proyectivas se


42

pueden derivar convirtiendo previamente los puntos a coordenadas afines y a continuación, tras eliminar previamente los denominadores, utilizaremos las mismas expresiones. Vemos que serán necesarias quince multiplicaciones y cinco cuadrados para la suma de puntos, según la ecuación (2.12), y cinco multiplicaciones y cinco cuadrados para el doblado de puntos (ecuación(2.13)). En términos de espacio requerido, la implementación en coordenadas afines necesita almacenar solamente dos variables temporales tanto en el caso de la suma como en el de doblado de puntos, mientras que la implementación proyectiva requiere almacenar nueve variables para la suma de puntos y cuatro para el caso del doblado.

El beneficio de la utilización de las coordenadas proyectivas radica en que no se requiere la operación de inversión que, puesto que es una operación compleja, requerirá un tiempo apreciable para su ejecución. Si el tiempo necesario para realizar 13 multiplicaciones y 4 cuadrados es menor que el que se requiere para una inversión, la suma de puntos en coordenadas proyectivas será más eficiente. Similarmente si el tiempo de la inversión es mayor que el de 3 multiplicaciones y 4 cuadrados, el doblado de puntos será más eficiente en coordenadas proyectivas.

Con todo esto y como resumen, llegamos a la conclusión de que la multiplicación y la inversión son las operaciones que más recursos consumen, y si bien la inversión requiere más espacio y tiempo que la multiplicación, es posible utilizar una única inversión para la multiplicación escalar si utilizamos la representación apropiada para los puntos. Por consiguiente, será imperativo optimizar los algoritmos encargados de realizar la multiplicación independientemente de cuál sea el sistema de coordenadas que finalmente empleemos.

2.2.2 ELECCIÓN DE LOS PARÁMETROS DE LA CURVA

La implementación de un sistema que trabaje con curvas elípticas requiere que se tomen una serie de decisiones con diferentes niveles de jerarquía, que dependerán del nivel hardware en que nos estemos moviendo y de las metas que se pretendan alcanzar en la implementación. Las diferentes decisiones que tenemos adoptar en los diferentes niveles son las que nos muestra la figura 2.4.

CAPÍTULO 2

43

• A nivel de cuerpo finito: o Elección del cuerpo finito de trabajo:

GF(2 )m GF( )p GF( )mp

o Selección de la base de representación de los elementos del cuerpo: Base normal Base polinomial.

o Selección de los algoritmos aritméticos para las operaciones sobre el cuerpo: Suma Multiplicación Reducción Inversión.

• A nivel de curva elíptica: o Elección del tipo de representación para los puntos de la

curva: Coordenadas Proyectivas Coordenadas Afines Coordenadas López-Dahab.

o Elección de algoritmos para suma y doblado de puntos de la curva. Suma Doblado

• A nivel de protocolo: o Elección del protocolo apropiado:

Intercambio de claves Firma digital Elección del algoritmo para realizar la multiplicación

escalar ·k P

Figura 2.4 – Niveles de decisión en un criptosistema basado en curvas elípticas


44

Estas elecciones nos permiten una amplia flexibilidad y hace que podamos ubicar nuestro criptosistema dentro de las condiciones de trabajo que persigamos.

En primer lugar, repasaremos la aritmética para las curvas elípticas definidas sobre los diferentes cuerpos sobre los que podemos trabajar: GF(p), GF(2m) y GF(pm). A continuación presentaremos diferentes métodos de realizar la multiplicación de puntos y posteriormente discutiremos los métodos de intercambio de claves y protocolos de firma. Los algoritmos que se presentan están limitados solamente a aquellos que son relevantes para el desarrollo de la tesis, pero podemos encontrar un estudio exhaustivo en [53] y en [25].

2.2.3 CURVAS ELÍPTICAS SOBRE GF(p)

Una curva elíptica E sobre el cuerpo GF( )p es el conjunto de soluciones (x, y) que satisfacen la ecuación simplificada de Weierstrass:

2 3y x ax b= + + (2.14)

con ,a b∈ y 3 24 27 0a b+ ≠ , conjuntamente con el punto al infinito .

Para el conjunto de puntos ( )GF( ) E p se puede definir una operación de

suma (+) de forma que ( (GF( )), )E p + es un grupo abeliano donde actúa como elemento neutro. Este grupo algebraico puede utilizarse para construir un criptosistema de curvas elípticas en el que la operación de suma quedaría definida de la siguiente forma:

( ) GF( )P P P P E p+ = + = ∀ ∈

• Si ( )( , ) GF( ) ( , ) ( , ) .P x y E p x y x y= ∈ → + − = Donde el punto

( )( , ) ( )x y E GF p− ∈ , se representa como –P .

• Si ( )1 1 )( , GF( ) P x y E p= ∈ y ( )2 2 )( , GF( ) ,Q x y E p= ∈ con

3 3 ( ),P Q P Q x y≠ ± → + = , donde:

23 1 2x x xλ= − − (2.15)

CAPÍTULO 2

45

( )3 1 3 1y x x yλ= − − (2.16)

2 1

2 1

y yx x

−=

−λ (2.17)

• Si ( )1 1 3 3 ( , GF( ) 2 ( ,) ),P x y E p P P P x y= ∈ → + = = donde:

23 12x xλ= − (2.18)

( )3 1 3 1y x x yλ= − − (2.19)

21

1

32x a

yλ

+= (2.20)

Esta última operación es la que habitualmente se denomina doblado de un punto.

Tabla 2.11: Algoritmo de suma de puntos en GF(p)

Entrada: ( ) ( ) ( )1 1 1 2 2 2 con parámetros , GF y los puntos , , E a b p P x y y P x y∈ = =

Salida: 1 2Q P P= + if 1P = , then return 2Q P← if 2 P = , then return 1Q P← if 1 2x x= then

if 1 2y y= then 21

1

3 mod

2x a

py+

←λ

elsif 1 2y y= − return Q ←

else 2 1 2 1

2 1 2 1 mod mod

y y y yp p

x x x x− −

← ←− −

λ λ

23 1 2x x xλ← − −

( )3 1 3 1y x x yλ← − −

Return ( )3 3( , )Q x y←


46

Obsérvese que la suma de dos puntos de una curva elíptica requiere varias operaciones sobre GF(p): una inversión, dos multiplicaciones, un cuadrado y seis sumas. Similarmente, el doblado de un punto de una curva elíptica requiere una inversión, dos multiplicaciones, dos cuadrados y ocho sumas. El algoritmo de la tabla 2.11 nos presenta la suma de dos puntos

2.2.4 CURVAS ELÍPTICAS SOBRE GF(2m)

Una curva elíptica E sobre el cuerpo GF(2 )m definida por los parámetros

, GF(2 )ma b∈ con b ≠ 0 es el conjunto de soluciones ( , ), P x y=

( , ) GF(2 )mx y∀ ∈ que satisfacen la ecuación:

2 3 2y xy x ax b+ = + + (2.21)

conjuntamente con el punto al infinito ( ) .

Como en el caso de GF(p), al grupo GF(2 )m puede dotarse de estructura de grupo abeliano. En este caso, la operación de suma queda definida de la siguiente forma:

( ) F(2 )G mP P P P E+ = + = ∀ ∈

• Si ( )( , ) GF(2 ( , ) ( , ) .) mP x y E x y x y= ∈ → + − = Donde el punto

( )( , ) )GF(2mx y E− ∈ , se representa como –P .

• Si ( )1 1 )( , G ( )F 2mP x y E= ∈ y ( )2 2 )( , G ( )F 2mQ x y E= ∈ con

3 3 )( ,P Q P Q x y≠ ± → + = , donde:

23 1 2x x x aλ λ= + + + + (2.22)

( )3 1 3 3 1y x x x yλ= + + + (2.23)

2 1

2 1

y yx x

+=

+λ (2.24)

• Si ( )1 1 3 3) )( , GF(2 2 ( , ),mP x y E P P P x y= ∈ → + = = donde:

CAPÍTULO 2

47

23x aλ λ= + + (2.25)

( )3 1 3 3 1y x x x yλ= + + + (2.26)

11

1

xx

yλ = + (2.27)

Como podemos comprobar, la suma de dos puntos diferentes de una curva elíptica en GF(2 )m requiere una inversión, dos multiplicaciones, una elevación al cuadrado y ocho sumas. El doblado de un punto requiere una inversión, dos multiplicaciones, un cuadrado y seis sumas. El algoritmo de la tabla 2.12 nos presenta la suma de dos puntos en coordenadas afines, independientemente de que sean iguales o no:

2.2.5 MULTIPLICACIÓN DE PUNTOS DE UNA CURVA ELÍPTICA

La multiplicación escalar de puntos de una curva elíptica es la operación que realiza el producto k · P; donde k es un entero positivo y P es un punto de la

Tabla 2.12: Algoritmo de suma de puntos en GF(2m)

Entrada: con parámetros , GF(2 y lo) s puntos:mE a b∈

( ) ( )1 1 1 2 2 2 , , P x y y P x y= =

Salida: 1 2Q P P= + if 1P = , then return 2Q P← if 2 P = , then return 1Q P← if 1 2x x= then

if 1 2y y= then 11

1

xx

y← +λ , ( )3 1 3 3 1y x x x yλ← + + +

elsif 1 2y y= − return Q ←

else 2 1

2 1

y yx x

+←

+λ , 2

3 1 2x x x aλ λ= + + + +

( )3 1 3 3 1y x x x yλ← + + +

Return ( )3 3 )( ,Q x y←


48

curva elíptica. Esta es la operación básica de la implementación del protocolo de intercambio de claves de cualquier criptosistema de curvas elípticas [54] y en los algoritmos de firma digital [45]. Existen varias formas de implementar la multiplicación de puntos:

• Binario • Forma no adyacente • Ventana • Montgomery

Cada uno de ellos aporta ventajas y desventajas dependiendo de las condiciones en que vayamos a trabajar. Podemos encontrar una comparación de los diferentes métodos en [53].

El método binario es el de implementación más simple y directa mediante desplazamientos y sumas, similar a los métodos de multiplicación o cuadrado descritos en los algoritmos de las tablas 2.6 y 2.7. Utilizando el método de izquierda a derecha (empezando por el bit más significativo) el algoritmo queda como muestra la tabla 2.13.

El tiempo necesario para la ejecución de este algoritmo dependerá de la cantidad de unos que contenga k y su valor medio será

2 .mS Dm∆ + ⋅∆ Donde

S∆ y D∆ representan, respectivamente, los tiempos necesarios para realizar la suma de dos puntos y el duplicado de un punto.

El método de forma no adyacente (NAF, Non-Adjacent Form) parte de la idea de que el cálculo del inverso de un punto es sencillo de calcular y su coste temporal es muy bajo. Utiliza una representación con signo para los dígitos

Tabla 2.13: Método binario para la multiplicación de puntos

Entrada: ( ) 2, con logP E mK k k+∈ ∈ <

Salida: ( )· , GF(2 )mQ k P Q E= ∈

Q ← for i = m – 1 downto 0 2·Q Q← if 1 then ik Q Q P= ← + Return (Q)

CAPÍTULO 2

49

binarios, de tal forma que 1

0

2n

ii

i

k k−

=

=∑ con { }1,0,1 .ik ∈ − El método NAF es

una representación más eficiente en la que no admiten valores distintos de cero consecutivos. Este método puede disminuir la cantidad de unos que forman la representación de un número, si bien la existencia de –1 implica una multiplicación por el inverso. El algoritmo para la obtención de la forma no adyacente de un entero positivo es el que se muestra en la tabla 2.14.

La ventaja de la utilización de la representación en forma no adyacente es que la media de valores distintos de cero se reduce en valor medio a n/3. Por tanto, la multiplicación mediante representación NAF tendrá como tiempo

Tabla 2.14: Obtención de la forma no adyacente de un entero positivo

Entrada: k Z +∈ Salida: NAFk 0i ← while k > 0 if k es impar then 2 ( mod4)ik k← −

else 0ik ←

2

ik kk

−←

1i i← + Return (k)

Tabla 2.15: Método NAF para la multiplicación de puntos

Entrada: ( )1

0

, 2j

iNAF i

i

k kKP E−

=

∈ =∑


Q ← for i = j – 1 downto 0 2·Q Q← if 1 then ik Q Q P= ← +

if 1 then ik Q Q P= ← − Return (Q)


50

de ejecución 3 .m

S Dm∆ + ⋅∆ Donde S∆ y D∆ representan, respectivamente,

los tiempos necesarios para realizar la suma de dos puntos y el duplicado de un punto y, por supuesto, asumiendo que las inversiones se realizan sin coste alguno.

Los métodos de ventana resultan particularmente útiles cuando se dispone de memoria para almacenar valores de puntos calculados previamente. Los FPGA disponen de una cantidad de memoria limitada y, además, estos bloques están distribuidos a lo largo de todo el FPGA. El acceso a los bloques de memoria es una de las operaciones más lentas en un FPGA, por lo que limitaremos el estudio a aquellos métodos que no requieren precomputación.

El método de Montgomery para la multiplicación escalar [55] se basa en el hecho de que la coordenada x del punto P + Q se puede obtener de las coordenadas de P, de Q, y de P – Q. En una primera iteración se calculan las coordenadas x de k·P y de (k+1)·P, a partir de las cuales se obtiene la coordenada y de k·P. El algoritmo de la tabla 3.16 muestra la multiplicación de puntos en coordenadas afines.

Tabla 2.16: Método de Montgomery para la multiplicación de puntos

Entrada: ( ) 2, con logP E mK k k+∈ ∈ <


2 21 2, /x x x x b x← ← +

for i = m – 2 downto 0

1

1 2

xt

x x←

+

if 2 2 21 2 2 21 then , /ik x x t t x x b x= ← + + ← +

else 2 2 21 1 1 2/ , x x b x x x t t← + ← + +

1 1 2 22

1 1 1 2

,

( )/( )

r x x r x x

y r r r x y x y

← + ← +

← + + +

Return (Q=(x1, y1))

CAPÍTULO 2

51

Podemos comprobar que este algoritmo realiza dos inversiones, dos multiplicaciones más una por la constante b, dos cuadrados y dos sumas, por lo que el coste de su ejecución será en término de estas operaciones:

2 2

2 2

#Inv. 2 log 2, #Mult.=2 log 4

#Suma 2 log 6, #Cuad.=2 log 2

k k

k k

= + + = + +

Donde #Inv., #Mult., #Suma y #Cuad. representan respectivamente el número de inversiones, multiplicaciones, sumas y cuadrados. Como podemos comprobar, el algoritmo no depende del número de unos y ceros que tenga la representación binaria de k.

53

CAPÍTULO 3

CODISEÑO HARDWARE-SOFTWARE. PRIMERA

APROXIMACIÓN La gran cantidad de pequeños dispositivos de bajo coste que nos rodea y que utilizamos frecuentemente los convierten en candidatos a utilizarse en aplicaciones criptográficas. Sin embargo, normalmente nos ofrecen una capacidad de computación reducida que no suele exceder de algunos MHz. Bajo estas limitaciones, los estándares que se nos presentan para la criptografía de clave pública hacen que estos dispositivos se vuelvan demasiado lentos para un protocolo de comunicaciones. Incluso podrían considerarse como inviables.

Cuando se utilizan aplicaciones que requieren un alto nivel de seguridad, como por ejemplo una smart card, una alternativa es el uso de un coprocesador criptográfico, si bien nos encontraremos con la desventaja del incremento del coste en términos de potencia y área del chip. Por otra parte, una solución completamente hardware puede chocar con la flexibilidad que suelen requerir las aplicaciones reales.

Una opción más viable es la utilización de un pequeño microprocesador al que le podamos realizar una extensión de su repertorio de instrucciones, con

CODISEÑO HARDWARE-SOFTWARE. PRIMERA APROXIMACIÓN

54

lo que añadiendo una pequeña cantidad de hardware podremos mantener la flexibilidad del microprocesador. La eficiencia de esta extensión no solo la mediremos en términos de la velocidad alcanzada, sino también en la disminución del tamaño del código, de la memoria requerida y del consumo. En este capítulo estudiaremos el uso de hardware reconfigurable conjuntamente con un microprocesador de 8 bits para obtener una relación coste/beneficios razonable mediante la extensión propuesta.

3.1 PLATAFORMA DE DESARROLLO La plataforma que utilizaremos para el desarrollo del sistema es una Nexys 2 de Digilent. Esta tarjeta integra un FPGA Xilinx Spartan3E-500, 16 MB de memoria RAM, 16 MB de memoria ROM y diferentes puertos de entrada/salida y periféricos. Si bien no integra de forma específica un microprocesador, podemos encontrar disponibles diferentes cores de código abierto optimizados para la integración en una FPGA. Puesto que no se adaptan a nuestras necesidades, hemos optado por describir y utilizar una simplificación de un símil del AVR fabricado por Atmel [56], un pequeño microcontrolador de sencillo diseño y fácil programación que se adapta perfectamente a nuestras necesidades.

Nuestro microcontrolador es de tipo RISC con arquitectura Harvard del que podemos destacar las siguientes características:

• Ocupa 700 elementos lógicos de una FPGA Spartan III de Xilinx.

• La frecuencia de funcionamiento puede ser de 27 MHz.

• Puede implementar todas las instrucciones descritas, lo que hace que dispongamos, sin variantes, de 65 instrucciones.

• Las instrucciones se ejecutan en un tiempo que va desde 1 a 4 ciclos de reloj.

• Dispone 32 registros de propósito general de 8 bits que se encuentran conectados directamente a la ALU.

El uso del FPGA no solo resulta interesante desde el punto de vista de la reconfigurabilidad y del prototipado. A demás de permitirnos realizar una extensión del hardware y que podremos añadir los operadores que nos sean necesarios, resulta una plataforma especialmente atractiva para la creación de sistemas empotrados. Puesto que tendremos el dispositivo final en un

CAPÍTULO 3

55

solo chip, puede ofrecernos unos incrementos de velocidad y una disminución del consumo que resultará muy interesante sobre todo en aquellas aplicaciones que requieran un uso intensivo.

El repertorio de instrucciones implementado es el que se indica en la tabla 3.1. Si bien se pueden realizar muchas más operaciones de las indicadas en el repertorio, a la hora del diseño se han suprimido todas aquellas que pueden implementarse a través de otras.

Memoria de ProgramaContador de Programa

Registro de Instrucción

Decodificador de Instrucciones

Registro de Estado

Registros de Propósito General (32x8)

Memoria de Datos

ALU

Líneas de E/S

Bus de Datos de 8 bits

Lógica de Control

Líneas de Control

Figura 3.1 – Estructura interna


56

Tabla 3.1: Repertorio de Instrucciones Implementado

Mnemónico Operandos Operación Instrucciones Lógicas y Aritméticas

ADD Rd, Rr Rd← Rd + Rr ADC Rd, Rr Rd← Rd + Rr + C ADIW Rd, K Rd← Rd+1:Rd + K SUB Rd, Rr Rd← Rd – Rr SUBI Rd, K Rd← Rd – K SUC Rd, Rr Rd← Rd – Rr – C SBCI Rd, K Rd← Rd – K – C SBIW Rd, K Rd+1:Rd← Rd+1:Rd – K CP Rd, Rr Rd – Rr CPC Rd, Rr Rd – Rr – C CPI Rd, K Rd – K AND Rd, Rr Rd← Rd · Rr ANDI Rd, K Rd← Rd · K OR Rd, Rr Rd← Rd ⋁ Rr ORI Rd, K Rd← Rd ⋁ K EOR Rd, Rr Rd← Rd ⊕Rr COM Rd Rd← $FF – Rd NEG Rd Rd← $00 – Rd INC Rd Rd← Rd + 1 DEC Rd Rd← Rd – 1

Instrucciones de Salto y Bifurcación RJMP k PC← PC + k + 1 JMP k PC← k RCALL k PC← PC + k + 1 CALL k PC← k RET PC← Stack RETI PC← Stack CPSE Rd, Rr If (Rd = Rr) PC← PC + 2 o 3 SBRC Rr, b If [Rr(b) = 0] PC← PC + 2 o 3 SBRS Rr, b If [Rr(b) = 1] PC← PC + 2 o 3 BRBS s , k If [SREG(s) = 1 PC← PC + k + 1 BRBC S, k If [SREG(s) = 1 PC← PC + k + 1

CAPÍTULO 3

57

Tabla 3.1 (cont.): Repertorio de Instrucciones Implementado

Mnemónico Operandos Operación Instrucciones de Transferencia de Datos

MOV Rd, Rr Rd← Rr LDI Rd, K Rd← K LDS Rd, k Rd← (k) LD Rd, X Rd← (X) LD Rd, X+ Rd← (X); X← X + 1 LD Rd, -X X← X – 1; Rd← (X) LD Rd, Y+ Rd← (Y); Y← Y + 1 LD Rd, -Y Y← Y – 1; Rd← (Y) LDD Rd, Y+q Rd← (Y+q) LD Rd, Z+ Rd← (Z); Z← Z + 1 LD Rd, -Z Z← Z – 1; Rd← (Z) LDD Rd, Z+q Rd← (Z+q) STS k, Rr (k)← Rr ST X, Rr (X)← Rr ST X+, Rr (X)← Rr; X← X + 1 ST -X, Rr X← X – 1; (X)← Rr ST Y+, Rr (Y)← Rr; Y← Y + 1 ST -Y, Rr Y← Y – 1; (Y)← Rr STD Y+q, Rr (Y+q)← Rr ST Z+, Rr (Z)← Rr; Z← Z + 1 ST -Z, Rr Z← Z – 1; (Z)← Rr STD Z+q, Rr (Z+q)← Rr PUSH Rr Stack← Rr POP Rd Rd← Stack

Instrucciones de bit y test de bits LSR Rd Rd(n)← Rd(n+1); Rd(7)← 0; C← Rd(7) ROR Rd Rd(7)← C; Rd(n)← Rd(n+1); C← Rd(0) ASR Rd Rd(n)← Rd(n+1), con n=0..6 SWAP Rd Rd(3..0) ↔ Rd(7..4) BSET s SREG(s)← 1 BCLR s SREG(s)← 0 BST Rr, b T ← Rr(b) BLD Rd, b Rd(b)← T


58

Figura 3.2 – Unidad de control obtenida

CAPÍTULO 3

59

Figura 3.3 – Unidad Aritmético-Lógica


60

Los resultados de ocupación en la FPGA utilizada Xilinx Spartan3E-500 son los que nos muestra la tabla 3.2. Podemos comprobar que, a pesar de estar utilizando un FPGA de tamaño reducido, los índices de ocupación de los elementos son los suficientemente pequeños como para poder abordar cualquier tipo de ampliación sin tener que afrontarnos a la necesidad de cambiar el dispositivo.

Tabla 3.2: Porcentajes de utilización de elementos en el FPGA

Lógica Elementos Utilizados Utilización Número de registros 865 9% LUTs de 4 entradas 2120 22%

Bloques de E/S 72 31%

3.2 CONSIDERACIONES PREVIAS DE LA IMPLEMENTACIÓN Para realizar una implementación eficiente, necesitaremos que el codiseño hardware-software que realicemos esté perfectamente acoplado y que la distribución de las tareas a realizar por cada una de las partes nos proporcione el mayor nivel de eficiencia posible.

Con esta finalidad, en primer lugar realizaremos una primera implementación software en lenguaje ensamblador de nuestro ECC que resultará fundamental para determinar los límites entre ambos dominios. Este estudio nos permitirá elegir aquellos elementos aceleradores hardware que ayuden a eliminar las deficiencias surgidas.

En primer lugar tendremos que apuntar que los campos binarios de la forma GF(2m) tienen un alto grado de dificultad en su implementación software debido al hecho de que no existe ninguna instrucción que constituya una multiplicación en GF(2), por lo que nos vemos obligados a definirla.

La elección del campo de trabajo estará marcada por el tamaño de palabra de que disponemos, si bien el uso aritmética libre de acarreos nos facilitará mucho la tarea. Para realizar este estudio hemos elegido el campo GF(2163), que es uno de los estándares recomendado, [57] y que equivaldría a un sistema RSA de 1024 bits (Tabla 1.3).

CAPÍTULO 3

61

3.3 ARITMÉTICA DEL CAMPO Puesto que vamos a utilizar la base polinomial como base de representación, el polinomio reductor para el campo elegido es 163 7 6 3( ) 1F x x x x x= + + + + [58] y puesto que el tamaño de palabra es de w = 8 bits, los datos estarán

divididos en con s segmentos cuyo valor será 1638 21m

ws = = = .

La suma es la operación más sencilla y la realizaremos simplemente mediante la operación XOR que dispone nuestro microcontrolador y que se realiza bit a bit entre los datos a operar. Esta operación se realiza en un solo ciclo de reloj. Necesitaremos 4 ciclos de reloj para la obtención de cada par de operandos y otros dos para guardar el resultado en memoría. Por tanto, el número de ciclos de reloj necesarios para realizar una suma será de 7s.

Si bien muchos multiplicadores de 8 bits incorporan una instrucción de multiplicación, no es nuestro caso. La multiplicación la deberemos realizar en dos pasos. En primer lugar la multiplicación polinomial de los dos datos y posteriormente la reducción modular del resultado. El método más simple para la multiplicación es el de sumas y desplazamientos, descrito en el algoritmo de la tabla 2.7, y su reducción mediante el algoritmo de la tabla 2.5.

Para realizar la multiplicación utilizaremos el algoritmo de Comba [59], que nos resultará particularmente útil al carecer de acarreos y podremos descomponerla en productos de w w× bits y almacenar en memoria el resultado solamente una vez hayamos alcanzado el valor final. Escrito en lenguaje ensamblador del microprocesador descrito, la rutina capaz de realizar un producto de 8 8× bits, emplea una media de 78 instrucciones en realizar un producto arbitrario. El tiempo total de ejecución dependerá del número total de ciclos de reloj que se requieran, si bien la inmensa mayoría de instrucciones requieren un ciclo de reloj y la media se sitúa por debajo de los 100 ciclos (98 concretamente).

Si generalizamos para productos compuestos por s palabras de 8 bits, necesitaremos adicionalmente siete instrucciones en cada iteración para generar los operandos y cinco para almacenar los componentes del producto final, lo que hace que se requieran un total de 2[(7 98) 5 ]s s+ + ciclos de reloj sin la reducción. Esto quiere decir que si tenemos un total de 21 palabras serán necesarios 46410 ciclos de reloj.


62

Obtener Ai,Bj

Prod = 0k= 7

k=k-1

¿k=0? Actualizar i,jActualizar Prod

Desp. Izda Producto Prod=Prod ( AND )ik jA B⊕

¿Fin? Reducir Prod

Figura 3.4 – Obtención de A * B

La reducción modular la realizamos mediante el algoritmo de la tabla 3.5. Escrita en lenguaje ensamblador de AVR, y particularizada para el polinomio reductor indicado, incluye una rutina compuesta por 22 productos junto con las instrucciones necesarias para leer y devolver los datos a la memoria, por lo que serán necesarios 121*(s + 1) ciclos de reloj.

Aunque podríamos utilizar la obtención del cuadrado a través de la multiplicación, la utilización del algoritmo de la tabla 3.6 nos permite un ahorro de tiempo sustancial debido a su simplicidad. Es suficiente con intercalar los ceros en las posiciones adecuadas y posteriormente realizar la reducción modular mediante la rutina de reducción anterior.

CAPÍTULO 3

63

Obtener Ai

B = 0, j= 1

¿k=0? Actualizar Cuadr

Despl. Izda Ai

Despl. Izda B con CarryDespl Izda B

Reducir Cuadr

k=3

k=k-1j=j-1

i=20

¿j=0?

¿i=0?i=i-1

si

sisi

no

no

no

Figura 3.5 – Obtención del cuadrado de A

Esta rutina está compuesta por 21 líneas que ejecutan 66 + 63(s – 1) instrucciones, lo que supone 1326 ciclos de reloj.

Para realizar la inversión podremos recurrir al algoritmo de Itoh-Tsujii, que se obtiene a partir de la ecuación (3.9). El cálculo del inverso de un elemento

163GF(2 )a∈ requerirá el cálculo de 162 12

162( )b a a−

= y su posterior elevación al

cuadrado (es decir, 2 1162[ ( )]b a a−= ). La cadena aditiva para 162 es la

siguiente:

U = {1, 2, 3, 4, 9, 19, 39, 79, 80, 162, 163}


64

Obtener b162(a) necesitará 10 pasos. En cada uno de ellos realizamos una multiplicación y un total de m – 1 cuadrados. Es decir, 162 cuadrados. Evidentemente, si trabajamos con coordenadas afines, esta operación tendrá un elevado coste y su eficiencia estará directamente relacionada con la del elemento multiplicador y el encargado de realizar los cuadrados.

Los resultados de la implementación de las operaciones en software son los que nos muestra la tabla 3.4. Dadas las operaciones a realizar, y teniendo en cuenta que la inversión la realizamos a través de multiplicaciones y cuadrados, la eficiencia de una implementación puramente software dependerá de la eficiencia con que realicemos las multiplicaciones, puesto que, como podemos comprobar, es la operación que requiere mayor cantidad de tiempo de ejecución y memoria.

Si nos centramos en la realización de operaciones sobre los puntos de una curva, la multiplicación es una operación de uso frecuente por lo que se convertirá rápidamente en el cuello de botella.

Tabla 3.3: Obtención de a-1 mediante el algoritmo de Itoh-Tsujii

Iteración bi Regla aditiva Exponenciación

1 b1 a 2 b2 b1+1

1 22 2 12 1 1·b b b a −= =

3 b3 b2+2 2 32 2 1

3 2 2·b b b a −= =

4 b4 b3+1 42 2 1

4 3 1·b b b a −= =

5 b5 b4+4 5 92 2 1

5 4 4·b b b a −= =

6 b6 b5+5 10 192 2 1

6 5 5·b b b a −= =

7 b7 b6+6 20 392 2 1

7 6 6·b b b a −= =

8 b8 b7+7 40 792 2 1

8 7 7·b b b a −= =

9 b9 b8+1 802 2 1

9 8 1·b b b a −= =

10 b10 b9+9 81 1622 2 1

10 9 9·b b b a −= =

11 b11 b10 1632 2 2

11 10b b a −= =

CAPÍTULO 3

65

Adicionalmente, un análisis más detallado del multiplicador nos muestra que una parte importante del tiempo se emplea en las operaciones de carga y almacenamiento debido al pequeño tamaño de los registros del microprocesador.

Por tanto, una extensión del hardware que integre este bloque funcional introduciría una potencial mejora, siendo deseable que redujese tanto el tiempo de operación como las necesidades de memoria para ofrecer un tiempo de respuesta que eliminase el cuello de botella.

Tabla 3.4: Coste de las operaciones realizadas en software

Operación Ciclos de Reloj Bytes de Código Suma 147 16

Multiplicación 46410 156 Cuadrado 1326 88 Reducción 2662 186

Tabla 3.5: Coste de las operaciones realizadas en software necesarias para la multiplicación escalar

Operación Ciclos de Reloj Tiempo de Respuesta (27 MHz)

Doblado de un punto 317564 13,49 ms Suma de puntos 364415 11,76 ms

3.4 EXTENSIÓN DEL REPERTORIO DE INSTRUCCIONES El repertorio de instrucciones disponible en nuestro microprocesador es claramente insuficiente para realizar las operaciones necesarias en las aplicaciones criptográficas. Puesto que tenemos la descripción del microprocesador realizada sobre VHDL podremos extender este repertorio de instrucciones para satisfacer en medida de lo posible las necesidades que han surgido.

Aunque existen diferentes formas de extender el procesador, la forma más inmediata que nos reduce la circuitería consiste en integrar esta extensión como parte de la Unidad Aritmético-Lógica. La lógica de control del procesador deberá extenderse también para soportar este hardware extra.


66

Cuando una de las nuevas instrucciones se cargue en el registro de instrucción, la unidad de control proporcionará las señales de control necesarias sobre el bloque Extensión. Este bloque debe poder comunicarse directamente con la Memoria de Datos para poder reducir los retardos debidos a las sucesivas cargas y almacenamientos de los registros de propósito general cuando tratamos los diferentes segmentos que componen un dato de gran tamaño (Figura 3.6).

Memoria de ProgramaContador de Programa

Registro de Instrucción

Decodificador de Instrucciones

Registro de Estado

Registros de Propósito General (32x8)

Memoria de Datos

ALU

Líneas de E/S

Bus de Datos de 8 bits

Lógica de Control

Líneas de Control

Extensión

Figura 3.6 – Estructura interna del microprocesador con el bloque extensor

Como hemos comentado en el apartado anterior, el principal elemento que debe contener nuestro circuito Extensión es un multiplicador. Para el caso en que estamos tratando, este multiplicador debe trabajar en GF(2163) y ocupar la mínima área.

CAPÍTULO 3

67

La Figura 3.7 muestra el bloque funcional del multiplicador. En él, los datos a operar se cargan directamente desde la memoria a dos de sus registros internos. En cualquier caso se necesitan al menos 21 ciclos para cargar los 21 bytes que componen los operandos. A continuación, el multiplicador operará los 163 bits hasta obtener el resultado final, que se almacenará en el registro resultado y se devolverá a memoria tras otros 21 ciclos.

La velocidad con que obtengamos el resultado dependerá directamente del tamaño de los registros, y consecuentemente del multiplicador. Lógicamente, esta velocidad será inversamente proporcional al área ocupada.

MULTIPLICADOR

Registros de Propósito General

Memoria de Datos

Registros Internos

ControlSeñales de control

Figura 3.7 – Estructura del bloque multiplicador

3.4.1 MULTIPLICADOR PARALELO La forma más sencilla consistirá en construir un multiplicador de 8x8 bits. En este caso el área empleada será mínima y la multiplicación en sí se realizará en un solo ciclo. El número de elementos que lo constituyen serían 64 puertas AND y 49 XOR conjuntamente con 3 registros de 8 bits y el resto de circuito de control. La multiplicación de 8x8 se realiza exactamente en 4 ciclos de reloj. Teniendo en cuenta la cantidad de productos que se realizan serán 21x21 = 441, la cantidad de ciclos de reloj necesarios ascenderá a 1764.


68

Cualquier mejora que introduzcamos en el multiplicador repercutirá sobre los resultados obtenidos, pero también sobre su tamaño. Así, podremos incrementar el número de bits a 16, 32 o incluso 64. Si el número de bits con que se trabaja es una cantidad importante, la alternativa al método clásico del algoritmo de lápiz y papel y que proporciona mejores resultados es al algoritmo de Karatsuba-Ofman [60]. Este método, propuesto por A. Karatsuba y Y. Ofman, describe un algoritmo del tipo divide y vencerás que puede reducir el número de puertas en este caso. Aquí, los productos de n × n bits se dividen en otros de n/2 × n/2 bits.

Dividamos ahora en dos partes Ai y Bi, de tal forma que sus n bits queden:

con 0, , 1

2

con , , 12

k

i

j

nA kA

nA j n

∈ … −

∈ … −

(3.1)

Utilizando este algoritmo el producto quedará:

( )/ /( )( )2 2 2n

n n ni j k j k j j j k k j k kR A b A B b B A B b A B A B b A B= + + = + + +

Si tenemos en cuenta que: ( )( )j k k j j k j k j j k kA B A B A A B B A B A B− = + + − −

Y llamamos

0 j jC A B=

1 ( )( )j k j kC A A B B= + +

2 k kC A B=

Nos quedará que:

( )/ /( )( )2 2 20 1 0 2 2

nn n n

j k j kA b A B b B C b C C C b C+ + = + − − +

Y puesto que estamos trabajando en un campo finito las sumas, al igual que las restas, son simples operaciones XOR, la ecuación se transforma en:

( )/ /( )( ) = + + = ⊕ ⊕ ⊕ ⊕n

n n ni j k j kR A b A B b B C b C C C b C2 2 2

0 0 1 2 2

CAPÍTULO 3

69

En concreto, cada multiplicador requerirá 3 productos estándar además de las puertas XOR adicionales. En concreto, el número de puertas requerido por la multiplicación será:

#

#

+

−

2

2

3puertas AND:

3puertas XOR 34

:

4

n

n n

Esto nos lleva a una mayor eficiencia en cuanto a espacio de este multiplicador que será mayor cuando mayor sea el número de bits con que trabajemos. Si utilizamos un multiplicador de 16 bits de este tipo, aunque el número de lectura y escrituras en memoria permanecerá invariable, el tiempo de respuesta se reducirá a menos de la mitad a costa de un incremento de superficie asumible.

Maximizar las prestaciones del hardware requerirá que adaptemos el diseño a la arquitectura del FPGA en que debe integrarse. La menor entidad que encontramos en un FPGA es la Tabla de Consulta (LUT, Look-Up Table). En una Spartan3E-500 las LUT poseen cuatro entradas que pueden configurarse para realizar cualquier función lógica. Las implementaciones más compactas se obtendrán en aquellos casos en que el uso de las LUT se haya maximizado.

Tabla 3.6: Elementos utilizados en función del tamaño del multiplicador

Nº de bits CLBs LUTs Biestables Tº de Respuesta 8 × 8 25 45 32 9.92 ns

16 × 16 88 169 64 9.97 ns 32 × 32 324 567 128 15.01 ns

La tabla 3.6 muestra las ocupaciones y los tiempos de respuesta para los diferentes tamaños de multiplicadores implementados. Estos tiempos de respuesta no incluyen los tiempos de carga de los datos y escritura de los resultados y podemos comprobar que en todos los casos el producto requerirá un ciclo de reloj. La frecuencia a la que se ha hecho funcionar el procesador es de 27MHz.

Teniendo en cuenta que los datos se encuentran en memoria estructurados en s palabras de 8 bits, que necesitamos adicionalmente siete instrucciones en cada iteración para generar los operandos y cinco para almacenar los


70

componentes del producto final, si los productos son de w × w se requieran

un total de + +

22 163[(7 5 ·8]s s

w ciclos de reloj sin la reducción. Los

resultados en función del tamaño del multiplicador son los que muestra la tabla 4.7.

Figura 3.8 – Estructura resultante del bloque multiplicador de 8 bits por 8 bits

CAPÍTULO 3

71

Tabla 3.7: Ciclos de reloj en función del tamaño del multiplicador

Numero de bits Ciclos de Reloj 8 × 8 6720

16 × 16 4160 32 × 32 3444

3.4.2 MULTIPLICADOR SERIE Alternativamente a los multiplicadores de bits en paralelo podemos utilizar los multiplicadores de bits en serie. Este tipo de multiplicador hardware es la solución más sencilla y que requerirá una menor superficie para su implementación. La estructura básica es la que se muestra en la figura 5.2, que discutiremos en el siguiente capítulo, y contiene la reducción integrada en el propio multiplicador. Como principal desventaja indicaremos que el campo en que trabajará será fijo y no podrá ser alterado sin modificar el hardware.

La implementación de un multiplicador de bits en serie con estructura LSB requerirá 326 puertas AND, 325 puertas XOR, dos registros de desplazamiento de 163 bits para los operandos y 326 registros de un bit encargados de mantener el polinomio reductor y de almacenar el resultado. Si excluimos los tiempos de carga de los operandos, una multiplicación de este tipo se realizará en 163 ciclos de reloj. Teniendo en cuenta que cada lectura o escritura en memoria requiere dos ciclos de reloj, si incorporamos los tiempos necesarios desde que el procesador comienza a direccionar los datos para incorporar A y B y se almacena el resultado final, el tiempo total asciende hasta los 578 ciclos de reloj. Esto nos lleva a una drástica reducción del tiempo de respuesta.

Tabla 3.8: Ocupación para un multiplicador serie de 163 × 163 bits

Núm. de bits CLBs LUTs 4 entradas Biestables 163 291 509 500


72

Figura 3.9 – Estructura resultante multiplicador LSB de 163 bits

CAPÍTULO 3

73

3.5 DEFICIENCIAS DEL SISTEMA PROPUESTO En los puntos que componen este capítulo hemos desarrollado los algoritmos necesarios para disponer de un sistema criptográfico de comunicaciones basado en un símil del procesador AVR con un juego de instrucciones simplificado.

Tal y como se describe, el componente más sobrecargado es el multiplicador que, siendo de propósito general, no está adaptado a las necesidades temporales de un sistema criptográfico.

En este sentido, es posible mejorar ostensiblemente las prestaciones de un procesador de 8 bits introduciendo algunas modificaciones que significan un incremento relativamente pequeño del hardware empleado (del orden máximo de 300 slices) y que incrementan significativamente la velocidad con que se puede realizar un producto. Esto nos llevará a la conclusión de que se puede ver incrementado en varías ordenes de magnitud la velocidad en la implementación de un criptosistema basado en curvas elípticas con la inclusión de un multiplicador de altas prestaciones. Adicionalmente esto también redundará en un ahorro de memoria, pues también se verá afectado el tamaño del código, que será más reducido.

75

CAPÍTULO 4

PROPUESTA DE MODELO CRIPTOPROCESADOR EN

GF(2m)

Con el paso del tiempo se han ido proponiendo varios estándares para la implementación de las técnicas de criptografía asimétrica como son ISO, ANSI y PKCS. Esta variedad de estándares ha conducido al diseño de una multitud de sistemas incompatibles, puesto que cada uno de ellos dependerá del problema matemático subyacente en que se base el estándar adoptado. Por ejemplo, el estándar para la criptografía de clave pública IEEE P1363 reconoce tres familias de problemas distintos: la factorización de enteros (FE), el logaritmo discreto (DL) y las curvas elípticas (CE). Cada familia tiene sus ventajas y sus desventajas. La factorización de enteros y el logaritmo discreto han sido estudiados durante muchos años, por lo que han sido escrutados minuciosamente. Por otra parte, las curvas elípticas parecen ser mucho más resistentes al criptoanálisis pero, como son relativamente recientes, muchos usuarios todavía son reacios a confiar en ellas.

Dependiendo de la elección que se haga, los diseñadores de sistemas pueden utilizar:

PROPUESTA DE CRIPTOPROCESADOR EN GF(2m)

76

• Técnicas basadas en software; principalmente con el objetivo de obtener algoritmos lo suficientemente ágiles para poder mantener la compatibilidad.

• Hardware específico; que tendrá un uso mucho más restringido y proporcionará comunicaciones seguras al poder ser utilizado solamente por los sistemas compatibles.

Las aproximaciones de criptografía pública basadas en software llevan a implementaciones computacionalmente intensivas con el subsiguiente coste temporal y que, por supuesto, requieren un consumo energético mucho mayor. En el pasado, estas ineficiencias quedaban enmascaradas por el hecho de que el usuario operaba desde una localización fija y sin restricciones previas en lo referente a requisitos de memoria y potencia del procesador. Sin embargo, en los sistemas con recursos limitados como los que nos ocupan, estas técnicas de implementación software deben ser reconsideradas mediante técnicas del tipo que se han descrito en el capítulo 3. La alternativa hardware nos lleva a una implementación mucho más eficiente y de menor consumo, pero excesivamente rígida y que no satisfará los requisitos de compatibilidad necesarios para incrementar su utilización en dispositivos portátiles.

En este capítulo se llegará a un compromiso entre estos dos extremos. Se tomarán las ventajas del hecho de que el conjunto de operaciones necesarias para implementar los algoritmos empleados en la criptografía de clave pública es pequeño y se conjugará con posibilidad de utilización de hardware reconfigurable para plasmarlos y que estén dotados de la ligereza suficiente. El resultado es un criptoprocesador basado en hardware reconfigurable.

4.1 IEEE P1363: EL ESTÁNDAR DE LA CRIPTOGRAFÍA DE

CLAVE PÚBLICA La publicación del IEEE P1363-2000 [61] y su posterior enmienda [46], estandariza el uso de los diferentes algoritmos criptográficos de clave pública con el objetivo de proporcionar las tres funciones básicas de la criptografía: establecimiento de claves, firmas digitales y encriptado de clave pública.

Las funciones de establecimiento de clave permiten a las dos partes que pretender comunicarse crear un conjunto de claves en presencia de cualquier espía. Estas claves pueden ser utilizadas posteriormente en

CAPÍTULO 4

77

algoritmos de clave secreta para encriptar/desencriptar los datos transmitidos entre ellos.

Las firmas digitales se utilizan para “firmar” los datos digitales de la misma forma que haría una persona de forma manuscrita. La firma digital proporciona una prueba irrefutable de que un determinado usuario ha generado unos datos y de que éstos no han sido modificados por un tercero.

El encriptado de clave pública no es más que la aplicación de uno de los algoritmos asimétricos existentes para codificar la información en aquellos casos en los que la criptografía de clave simétrica no es viable.

4.1.1 LOGARITMO DISCRETO (DL)

El problema de encontrar el logaritmo discreto en un cuerpo finito fue la base del primer algoritmo de criptografía asimétrica en apatrecer. Fue propuesto por Diffie y Hellman en 1976 [29]. Su seguridad radica en la dificultad de

calcular logaritmos en un grupo multiplicativo finito, como puede ser *p o

GF(2p) siendo p un número primo grande. El algoritmo explota el hecho de que dado un generador g de un grupo G, es fácil de calcular ∈ag G siendo a un entero cualquiera, pero para grupos de un orden lo suficientemente grande, a partir de ga es computacionalmente inviable la obtención de a. Por tanto, nuestros usuarios, Andrés y Beatriz, pueden establecer un secreto de forma sencilla a través del siguiente protocolo:

1. Andrés y Beatriz eligen un generador g y un grupo G, que no tienen por qué ser secretos.

2. Andrés y Beatriz generan un valor aleatorio, a y b respectivamente, que deben mantener en secreto.

3. Andrés manda ga a Beatriz, y ésta manda gb a Andrés 4. Andrés calcula =( )b a abg g y Beatriz calcula =( )a b abg g

Al final del protocolo Andrés y Beatriz comparten el valor secreto gab, mientras que un espía, Carlos, solo tendrá los valores ga y gb. Si asumimos que el cálculo de logaritmos sobre G es impracticable, Carlos solo podrá obtener ga+b. Por tanto, Andres y Beatriz han sido capaces de compartir un secreto a través de un canal inseguro.


78

Otra técnica de encriptado y generación de firmas basada en el problema del logaritmo discreto es la propuesta por ElGamal [30], si bien utiliza el mismo esquema de Diffie y Hellman para la generación de claves y realiza todos los cálculos sobre cuerpo multiplicativo, como puede ser

*p o GF(2p).

4.1.2 FACTORIZACIÓN DE ENTEROS (IF)

La factorización de enteros fue presentada en 1978 como método de implementación de la criptografía de clave pública con la introducción del algoritmo RSA [28]. Los algoritmos de factorización de enteros emplean el subgrupo multiplicativo formado por los enteros en módulo N, donde N es un entero grande compuesto por n dígitos formado por el producto de dos números aleatorios p y q de tamaño n/2. El algoritmo RSA se basa en el hecho de que el orden del subgrupo *

n es φ = − −( ) ( 1)( 1)n p q y, por tanto, para

cualquier elemento a ∈*na se debe mantener la relación:

φ =( ) 1modna n (4.1) A continuación se eligen dos valores d y e que satisfagan la relación:

φ⋅ =1mod ( )e d n (4.2)

El valor de e conjuntamente con el valor de n forman la denominada clave pública. El valor de d será el elemento secreto y representa la clave privada. Con estos valores, se pueden encriptar un valor x utilizando la exponenciación modular con e y desencriptar el resultado utilizando la exponenciación modular con d. La encriptación de un valor x < n se lleva a cabo realizando:

= modec x n (4.3)

Y la desencriptación:

= moddx c n (4.4)

Para lo que debemos tener en cuenta que:

( ) 1

( )

mod ( ) mod mod

mod mod

d e d a n

a n

c n x n x n

x x n x n

φ

φ

+= = =

= ⋅ = (4.5)

CAPÍTULO 4

79

Evidentemente, si podemos factorizar n podremos calcular φ( )n y obtener d basándonos en el hecho de que φ−= 1 mod ( )d e n . Por tanto, la ruptura de RSA no es más que el problema de la factorización de enteros. También podemos observar que la operación de encriptado y desencriptado es conmutativa, por lo que esta característica tiene un amplio uso dentro de la generación de firmas digitales.

4.1.3 LOGARITMO DISCRETO SOBRE CURVAS ELÍPTICAS (ECDL)

El problema del logaritmo discreto está íntimamente relacionado con el problema del logaritmo discreto sobre grupos multiplicativos, pero ahora hemos de tener en cuenta que el grupo estará constituido por el conjunto de puntos que forman parte de la curva elíptica en el cuerpo GF(q), donde q es un primo o 2m, y que la operación sobre el grupo es la suma en lugar del producto. Por tanto, el problema del logaritmo discreto sobre curvas elípticas yace en la dificultad de determinar un entero n partiendo solo de la curva E y de los puntos P y n·P.

El estándar IEEE P1363-2000 describe los esquemas de establecimiento de clave basados en los trabajos de Diffie y Hellman [29] y de Menezes, Qu y Vanstone [62]. Por otra parte, la firma digital utiliza el trabajo de Nyberg y Rueppel [63] y el Algoritmo de Firma Digital (DSA) [45]. Las operación básicas que se realiza consiste en la suma de puntos sobre el grupo aditivo formado por la curva elíptica sobre GF(2m).

Las ventajas de utilizar curvas elípticas ya fueron descritas en el capítulo 1.

4.2 DEFINICIÓN DE LA ARQUITECTURA Y DEL CONJUNTO DE

INSTRUCCIONES La implementación en hardware de operadores que trabajan en campos de característica dos es particularmente adecuada debido a que no solamente simplifica las operaciones al tratarse de aritmética sin acarreo sino que también se traduce en una disminución directa de los recursos empleados en su implementación. La definición del conjunto de instrucciones que formarán parte del criptoprocesador vendrá determinada por las


80

especificaciones descritas en la norma IEEE P1363-2000. Cada una de las funciones primitivas descritas en este documento requiere una serie de funciones que deben ser consideradas y que marcarán el juego de instrucciones del procesador. Si se va a trabajar sobre curvas elípticas, los cálculos que se deben realizar implican operar puntos de la curva elíptica y será necesario:

• Sumar puntos • Duplicar un punto • Multiplicación escalar

Protocolo

Operaciones sobre puntos

Aritmética de cuerpos finitos

Operaciones lógicas

Figura 4.1 – Funcionalidad de un criptosistema basado en curvas elípticas

Para poder realizar estas operaciones necesitaremos trabajar en en GF(2m), donde necesitaremos:

• Sumar • Multiplicar • Realizar inversiones • Elevar al cuadrado

La necesidad de estas operaciones queda reflejada en las figuras 4.1 y 4.2.

CAPÍTULO 4

81

Suma Multiplicación Cuadrado Inversión

Operaciones sobre el cuerpo finito

Multiplicación SumaOperaciones sobre puntos de la curva

Protocolos CCE

Figura 4.2 – Interacción entre las diferentes operaciones

Las instrucciones que se derivan de las operaciones que deben realizarse son las siguientes:

Sumar en GF(2m) Multiplicar en GF(2m) Calcular el inverso en GF(2m) Obtener el cuadrado en GF(2m) Establecer el campo de trabajo m Dividir en GF(2m) Duplicar un punto de la curva elíptica Sumar dos puntos de la curva elíptica:

A las que deberemos unir otras instrucciones de control y auxiliares que nos permitan mover información en el entorno del procesador.

Leer datos del exterior Enviar datos al exterior Transferir información entre registros Comparar registros Realizar saltos incondicionales en la secuencia de ejecución de un

programa


82

Realizar saltos condicionales en la secuencia de ejecución de un programa

4.3 ARQUITECTURA En cuanto a la arquitectura, el procesador debe de estar dotado de una unidad aritmético-lógica capaz de realizar las operaciones está compuesto por tres bloques principales: el circuito de control y la memoria de microprograma, el interface de entrada salida y la ruta de datos reconfigurable, que contendrá la unidad aritmético-lógica.

UnidadReconfigurable

InterfaceEntrada/Salida

Instrucción

Datos

Unidad de Control

Memoria de Microprograma

Figura 4.3 – Visión general de la arquitectura del procesador

Hemos de tener en cuenta que, por el juego de instrucciones que hemos considerado, tendremos operaciones que se realizarán directamente en el hardware, otras recurrirán a un microprograma que describa la secuencia necesaria para su ejecución se apoyándose en el hardware y, finalmente, un tercer grupo de instrucciones de desplazamiento y control.

La unidad reconfigurable nos permitirá modificar en cualquier momento el tamaño de los operandos y el tamaño de palabra que se utilice para la comunicación con el exterior.

CAPÍTULO 4

83

Para realizar el modelado, se ha parametrizado el tamaño de los operandos utilizados en el procesador de forma que nos permita trabajar en uno de los campos recomendados por el N.I.S.T. o el S.E.C. [57]. Requeriremos el uso de un interface de entrada salida flexible que nos permita transferir información hacia o desde el procesador y, por tanto, comunicarnos con el resto del sistema de forma eficiente sea cual sea su tamaño de palabra. El tamaño utilizado para la implementación final ha sido de 32 bits, basándonos en un criterio puramente económico debido al tamaño de los buses de los sistemas predominantes hoy por hoy. Este tamaño nos permite una transferencia relativamente rápida. El uso de un polinomio de grado n

supondrá operandos de (n + 1) bit y 132

n+

ciclos de carga para cada uno

de ellos.

Tabla 4.1: Tamaños de campo recomendados y polinomio reductor asociado

Estándar Tamaño del campo (m)

Polinomio Reductor

SEC 113 113 9 1x x+ + SEC 131 131 8 3 2 1x x x x+ + + +

SEC, NIST 163 163 7 6 3 1x x x x+ + + + SEC 193 193 15 1x x+ +

SEC, NIST 233 233 74 1x x+ + SEC 239 239 158 1x x+ +

SEC, NIST 283 283 12 7 5 1x x x x+ + + + SEC, NIST 409 409 87 1x x+ + SEC, NIST 571 571 10 5 2 1x x x x+ + + +

La ruta de datos reconfigurable, cuya arquitectura se muestra en la figura 4.4, está compuesta principalmente por cuatro bloques funcionales diferenciados: un banco compuesto por ocho registros, una unidad sumadora, una unidad multiplicadora, un inversor y los registros específicos. Estos elementos serán la encargada de realizar las operaciones definidas anteriormente.


84

El diseño del banco de registros se ha realizado de forma que se pueda acceder a cada uno de ellos de forma individual en un solo ciclo de reloj.

El circuito sumador/comparador también realiza la comparación de dos magnitudes de n bits en un solo ciclo de reloj, pues simplemente realiza la XOR de ambos operados y que será equivalente a la suma en GF(2m). Adicionalmente actuará sobre el flag Z.

Veamos ahora de forma más detallada las posibilidades que se nos presentan para las operaciones que constituirán la unidad aritmético-lógica.

Multiplicador Sumador/Comparador Inversor

Registros específicos

y temporalesBa

nco

deR

egis

tros

Figura 4.4 – Ruta de datos

4.4 IMPLEMENTACIÓN DE LOS OPERADORES Como hemos visto en la descripción de las instrucciones, el criptoprocesador realiza una serie de operaciones que estarán implementadas directamente en hardware y otras que, si bien no lo están directamente, se realizarán mediante algoritmos que están compuestos por otras instrucciones básicas. Describamos ahora los operadores que podremos utilizar para cada una de ellas.

4.4.1 SUMADOR/COMPARADOR

La operación más sencilla que podemos realizar sobre un cuerpo finito de la forma GF(2m) es la suma de dos elementos del cuerpo, ya que se reduce a

CAPÍTULO 4

85

realizar la operación XOR bit a bit entre ellos. La resta la obtendremos exactamente de la misma forma debido a que una resta no es más que la suma del minuendo con el inverso aditivo del sustraendo y en un cuerpo finito GF(2m) tenemos que cada elemento es su propio inverso aditivo.

1

101

0

0

1 21 1 2 2 0 0

( )( ) ( ) mod2

( )

( ) ( ) ( )

mi

i mi i

i imii

ii

m mm m m m

A x a xS x a b x

B x b x

S x a b x a b x a b

−

−=

−=

=

− −− − − −

= = +

= = ⊕ + ⊕ + + ⊕

∑∑

∑

(4.6)

Escribiendo de forma más específica el algoritmo de la tabla 2.4 obtenemos el algoritmo de suma/resta de la tabla 4.2. Puesto que esta operación se realiza bit a bit en paralelo, su complejidad temporal será (1) periodos de reloj. Como necesitaremos m puertas XOR en paralelo para realizar la operación, la complejidad espacial será ( )m .

En consecuencia, la operación de suma en se realiza sencillamente mediante un circuito similar al de la figura 4.1. Estará compuesto por m puertas XOR con un tiempo de latencia de 1 ciclo de reloj.

am-1 am-2 bm-1 bm-2

a1 a0 b1 b0

sm-1 sm-2 s1 s0

. . . . . . .

Figura 4.5 - Suma en GF(2m).


86

Puesto que la comparación la podemos realizar mediante la operación de resta, el comparador utilizará este mismo operador y solamente actuará sobre el flag Z.

4.4.2 MULTIPLICADOR

El elemento principal y de más trascendencia dentro de la unidad aritmética de un criptoprocesador es su multiplicador. Las investigaciones sobre posibles arquitecturas para multiplicadores que operen en GF(2m) con base polinomial se concentraron inicialmente en los multiplicadores paralelos y de bits en serie [64] y posteriormente se introdujeron otros tipos como son los multiplicadores híbridos [65] y los de dígitos en serie [66]. Tomando estos modelos como base han aparecido variantes que tratan de mejorar algunos de sus aspectos funcionales, como por ejemplo el propuesto en [67] para bits en serie, los multiplicadores super-serie [68], o de bits en paralelo [69]. Todos ellos presentan distintas características de complejidad espacial y temporal, por lo que estarán indicados para su uso en determinadas aplicaciones.

Los multiplicadores híbridos son los únicos cuyo uso está restringido a los campos compuestos, por lo que su utilización está desaconsejada [70]. Por otra parte, el gran tamaño de los campos utilizados para aplicaciones criptográficas, con valores de m que van desde 160 hasta 1024, hacen que el empleo de arquitecturas de multiplicadores paralelos sea impracticable para cualquier aplicación. En consecuencia, el presente trabajo se centrará en las arquitecturas correspondientes a los multiplicadores de bits en serie y de dígitos en serie.

En las siguientes secciones describiremos las dos versiones básicas de estos tipos de multiplicadores.

Tabla 4.2: Algoritmo para la suma en GF(2m)

Entrada: − −= … = …1 1 0 1 1 0( ) ( , , , ) , ( ) ( , , , , )m m mA x a a a B x b b b b Salida: −= + = …1 1 0( ) ( ) ( ), con ( ) ( , , , )mS x A x B x S x c c c for 1 downto 0i m= − = ⊕( )i i is a b

CAPÍTULO 4

87

MULTIPLICADORES DE BITS EN SERIE EN GF(2M)

El funcionamiento de los multiplicadores en serie se basa en el procesado de todos los coeficientes de forma paralela del multiplicando en primer lugar, mientras que los coeficientes del multiplicando se procesan en serie. La multiplicación puede realizarse de dos formas básicas, dependiendo del orden en que se procesan los coeficientes del multiplicador y del multiplicando. Se habla de LSB cuando se procesa en primer lugar el elemento menos significativo y se finaliza con el más significativo y de MSB cuando se invierte el orden y el que se toma en primer lugar es el elemento más significativo y en último lugar el menos significativo.

Un elemento A en GF(2m) tendrá la forma:

( )−

− −− −

=

= = + +…+ +∑1

1 21 2 1 0

0

mi m m

i m mi

A x a x a x a x a x a (4.7)

donde los coeficientes ∈GF(2)ia están definidos sobre un polinomio irreducible de la forma:

( )−

− −− −

=

= + = + + +…+ +∑1

1 21 2 1 0

0

mm i m m m

i m mi

F x x f x x f x f x f x f (4.8)

Los coeficientes de un elemento A de un cuerpo GF(2m) también pueden escribirse como un vector A = (am-1, am-2, …, a1, a0).

La multiplicación en GF(2m) utilizando base polinomial para dos elementos A y B se obtiene calculando:

=( ) ( ) · ( ) mod ( )R x A x B x F x (4.9)

donde R(x) es un polinomio de grado m–1 representativo de un elementoGF(2 )mR∈ . Por tanto, una multiplicación se realiza en GF(2 )m mediante el

producto de los dos polinomios en módulo el polinomio irreducible F(x). Desarrollemos la ecuación (4.9).

( ) ( ) ( ) ( )− −

= =

= = =

∑ ∑1 1

0 0

( ) mod mod m m

i ii i

i i

R x A x b x F x A x b x F x (4.10)


88

( ) ( ) ( ) ( ) ( )− −− − + +…+ + =

1 21 2 1 0 mod m m

m mA x b x A x b x A x b x A x b F x

]

− −− −= + + +

+ + =

1 21 2

1 0

( ) mod ( ) ( ) mod ( )

( ) mod ( ) ( )

m mm mA x b x F x A x b x F x

A x b x F x A x b (4.11)

( ) ( ) ( ) ( )

( ) ( ) ( )− −+ +

+ +

= +

1 2

01

mod mod

mod

m mA x b F x A x b x F x

A x b x F x A x b

x (4.12)

Esta ecuación se puede resolver de dos formas diferentes, dependiendo del orden en el que tomemos los coeficientes de B(x). Podemos empezar a partir del bit menos significativo (b0), con lo que tendremos un esquema LSB o bien comenzar por el extremo opuesto partiendo de bm-1, con lo que tendremos una estructura MSB.

La arquitectura LSB parte de la ecuación (4.11). Llamemos C(x) al producto xA(x):

−

− −− −

=

−− −

=

= = + +…+ +

+ +…= +

=

+

∑1

1 21 2 1 0

01 2

1 2 1 0

( ) ( )

( ) )(m

i m mi m m

im m

m m

a x x a x a x a x a

a x a x a x

C x A x x

x x

a

C

x

(4.13)

Esta expresión requiere la reducción de xm a módulo F(x). En general, la aritmética en módulo F(x) es equivalente a sustituir cada aparición de F(x) por 0. En otras palabras, ( ) ≡ 0 mod ( )F x F x en GF(2), y puesto que el

polinomio irreducible viene dado por ( )−

=

= +∑1

0

mm i

ii

F x x f x , tendremos que:

( ) ( )−

=

= + ≡∑1

0

0 mod m

m ii

i

F x x f x F x (4.14)

luego:

( )−

=

≡∑1

0

mod m

m ii

i

x f x F x (4.15)

por tanto, en GF(2), también tendrá que cumplirse que:

−

=

≡∑1

0

mod ( )m

m ii

i

x F x f x (4.16)

La ecuación (4.13) se puede rescribir de la forma:

CAPÍTULO 4

89

−−

− −

−−

=

= + =

= + + + +

+…+ + ∑2

12 1

0 1 2 10

10 1 2 1

( )

mm i

m m ii

mm

C x x

c c x c x

a a x a x a f x

c x (4.17)

donde c0 = am-1· f0 y ci = ci-1 + am-1· fi con i = 1, 2, …, m-1.

Sustituyendo en la ecuación (4.11) obtenemos una expresión que se puede resolver de forma recursiva teniendo en cuenta que en cada iteración k obtendremos:

( ) ( ) ( 1)k k kj j i jr b c r −= + (4.18)

En esta ecuación, el superíndice (k) denota el número de iteración en que nos encontramos, mientras que los subíndices seguirán haciendo referencia a índice del coeficiente. Después de realizar k iteraciones tendremos A(x) · B(x) mod F(x). La figura 4.6 nos muestra este multiplicador.

Asi pues complejidad espacial del multiplicador LSB será de 2m puertas AND, 2m – 1 puertas XOR y 2m registros, sin considerar el posible método de introducción de B(x) ni los registros necesarios para almacenar el polinomio reductor F(x). En cuanto a la complejidad temporal, puesto que procesamos un bit del resultado en cada periodo de reloj será ( )m .

Tabla 4.3: Algoritmo de multiplicación LSB en GF(2m)

Entrada: − − − −

− −

= =

=1 2 0 1 2 0

1 2 0

( ) ( , , , ), ( ) ( , , , )( ) ( , , , )

m m m m

m m

A x a a a B x b b bF x f f f

Salida: − −= ⋅ = 1 2 0( ) ( ) ( )mod ( ) con ( ) ( , , , )m mR x A x B x F x R x r r r

== −

( ) 0 0 1

P xfor i to m

= ⋅ +

= ⋅

( ) ( ) ( )

( ) ( ) mod ( )i

i

R x b A x R x

A x A x x F x


90

Para obtener la arquitectura MSB partiremos de la ecuación (4.12). Tomemos esta ecuación y hagamos:

= ⋅( ) ( )i ir x A x b (4.19)

con lo que se nos transformará en:

1 2

1 0

( ) [ [[ ( )] mod ( ) ( )] mod ( )( )] mod ( ) ( )

m mR x r x x F x r x x F xr x x F x r x

− −= … + +

+…+ + (4.20)

esta ecuación la podemos resolver de forma recursiva calculando en cada iteración:

( ) ( 1)

(0)

( ) ( ) mod ( ) ( )

con 1, , ( ) 0

k km kr x r x x F x r x

k m y r x

−−= +

= … =

Como ocurría en el caso anterior, el superíndice (k) denota el número de iteración en que nos encontramos, y los subíndices seguirán haciendo referencia a índice del coeficiente. Después de realizar k iteraciones tendremos que r(x)(k) = A(x)· B(x) mod F(x) = R(x).

Alternativamente, podemos escribir la ecuación (4.20) de la forma:

f1

a0

f2

a1

fm-1

am-1

r0 r1 rm-1

bm-1, …,b1,b0

f0

Figura 4.6 - Multiplicador LSB de m bits en serie

CAPÍTULO 4

91

( ) ( 1)

( 1)

( ) ( ) mod ( ) ( )

( ) ( ) mod ( )

k km k

km k

r x r x x F x r x

r x x r x F x

−−

−−

= + =

= + (4.21)

y haciendo

( 1) ( )( ) ( ) ( )k km kr x x r x s x−− + = (4.22)

tendremos que s(x)(k) representará la suma intermedia en el paso k de iteración antes de la reducción y que se calcula sumando el producto parcial

rm–k(x) a r(x)(k–1)x. Por tanto, en cualquier paso de la iteración debemos realizar dos operaciones: calcular la suma intermedia s(x)(k) y su reducción a modulo F(x).

Cada suma s(x)(k) tendrá, como máximo, grado m antes de su reducción, puesto que, desarrollando las expresiones en su forma polinomial:

1 1

( ) ( 1)( )

0 0

( )m m

k k i ii i m k

i i

s x r x x a x b− −

−−

= =

= + ∑ ∑ (4.23)

( )

1 1( ) ( 1) ( 1)

1 11 0

( )m m

k k m k i im i i m k

i i

s x r x r x a x b− −

− −− − −

= =

= + +∑ ∑ (4.24)

El cálculo de r(x)(k) = s(x)(k) mod F(x) requiere la reducción de xm a módulo F(x). Aplicando la ecuación (4.15) para reducir xm y obtener un polinomio de grado inferior a m en la ecuación (4.24):

1 1 1

( ) ( 1) ( 1)1 1

0 1 0

( ) ·m m m

k k i k i im i i i m k

i i i

s x r f x r x a x b− − −

− −− − −

= = =

= + +∑ ∑ ∑ (4.25)

( )1

( ) ( 1) ( 1)1 1

0

( ) ·m

k k k im i i i m k

i

s x r f r a b x−

− −− − −

=

= + +∑ (4.26)

Puesto que la expresión inicial tiene un rango diferente para i en el segundo sumatorio, deberemos tener en cuenta que r-1 = 0.

Los coeficientes ri del polinomio t(x) después de k iteraciones serán:

( ) ( 1)0 1 0 0( ) ( )k k

m m kr r f a b−− −= ⋅ + ⋅ (4.27)

( ) ( 1) ( 1)1 1( ) ( )k k k

i m i i i m kr r f r a b− −− − −= ⋅ + + ⋅ (4.28)


92

Las ecuaciones (4.27) y (4.28) describen funcionalmente una celda de 1 bits que utilizará un multiplicador MSB de bits en serie. Un multiplicador de este tipo que trabaje en GF(2m) requerirá m pulsos de reloj para realizar una multiplicación, y consistirá en 2m puertas AND de dos entradas y 2m puertas XOR también de dos entradas. La figura 4.7 nos muestra este multiplicador.

MULTIPLICADORES DE DÍGITOS EN SERIE EN GF(2m)

Con objeto de reducir el número de iteraciones que se requieren para realizar una multiplicación serie a nivel de bit, deberemos modificar el multiplicador. Como opción se presenta la posibilidad de gestionar los operandos, multiplicando y multiplicador, de una forma diferente a lo que lo hemos hecho hasta ahora. Por ejemplo, podemos dividir el multiplicador B(x) en palabras (o dígitos) compuestas por w bits y operarlas de forma simultánea en lugar de hacerlo bit a bit.

Si lo hacemos de esta forma, dividiremos los m coeficientes de B(x) en n palabras (dígitos) de 2 ó más bits, que representaremos por Bi(x) y cuyo

número será mnw =

. Si m no fuera múltiplo del tamaño del dígito w bastaría

am-1 am-2 a1 a0

rm-1 rm-2 rm-3

fm-1 fm-2 f1

r1

f0

r0

bm-1,bm-2, …,b1,b0

Figura 4.7 - Multiplicador MSB de m bits en serie

CAPÍTULO 4

93

con completar con ceros por la izquierda el dígito más significativo hasta que lo fuera. Por tanto, podremos escribir B(x) de la siguiente forma:

1

( 1) ( 2)1 2

0

1 02

2

( ) ( ) ( ) ( )

( ) ( )( )

niw n w n w

i n ni

ww

B x B x x B x x B x x

B x x B xB x x

−− −

− −=

= = + +

+

+

+ +

∑

(4.29)

donde cada uno de los dígitos Bi(x) viene dado por la ecuación:

1

0( )

wj

i iw jj

B x b x−

+=

=∑ (4.30)

Y haciendo uso de la ecuación (4.29) el producto R(x) = A(x)·B(x) mod F(x) tendrá la forma:

1

0

1

0

( ) ( ) ( )mod ( ) ( ) ( ) mod ( )

( ) ( ) mod ( )

niw

ii

niw

ii

R x A x B x F x A x B x x F x

A x B x x F x

−

=

−

=

= ⋅ = =

=

∑

∑ (4.31)

Observando la ecuación (4.31) podremos comprobar que es similar a la ecuación (4.10) que obtuvimos cuando trabajábamos con bits. Esto implica que para la multiplicación de dígitos en GF(2) podremos realizar un proceso similar al que realizamos para la multiplicación de bits.

( ) ( )( ) ( ) ( )

( 1) ( 2)1 2

1 0

( )

mod

( ) ( )

... ( ) ( )

n w n wn n

w

R x A x B x A x B x

A x B x A x Bx x

x x

x F

− −− −= + +…

+ + (4.32)

( ) ( )( ) ( ) ( )

( 1)1

1 0

( ) mod ( )

... ( ) ( )mod

n wn

w

R x A x B x F x

A x B x F x B xAx x

x −−= +…

+ + =

(4.33)

( )( ) ( )

1

1 0

( ) mod ( )

( ) ( )

wn

w

A x B x x F x

A x B x x A x B x−

= … +… …+ +

(4.34)

Nuevamente nos encontramos en la misma situación a la que teníamos cuando trabajábamos a nivel de bit y esta ecuación se puede resolver de dos formas diferentes, dependiendo del orden en el que tomemos los coeficientes de B(x). Podemos empezar a partir dígito menos significativo (B0), con lo que tendremos un esquema LSD o bien comenzar por el más significativo (Bm-1), con lo que tendremos una estructura MSD.


94

MULTIPLICADOR CON ESTRUCTURA MSD

El multiplicador de dígitos con estructura MSD es una generalización del multiplicador MSB en el que los dígitos del operando B se procesan empezando por el más significativo. La tabla 4.4 nos muestra el algoritmo de forma más detallada.

Como vemos en el paso 4 de este algoritmo aparecen productos de la forma ( ) mod ( )nA x x F x⋅ que deben ser reducidos. Como ocurría en el caso del

multiplicador MSB se pueden derivar ecuaciones para la reducción modular para un polinomio genérico irreducible F(x). Sin embargo resulta más interesante buscar polinomios que minimicen la complejidad de la operación de reducción y de esta forma podemos aplicar los teoremas propuestos por Song y Parhi en [9]. Aunque originalmente están propuestos sobre un multiplicador LSD son perfectamente aplicables a un multiplicador MSD, pues el proceso de reducción es similar.

Teorema 1. Supogamos que tenemos un polinomio irreducible tiene la forma 1

0( )

km k j

k jj

F x x g x g x−

=

= + +∑ , con k < m. Para t ≤ m – 1 – k, xm+t puede reducirse

a un grado inferior a m en un solo paso mediante la expresión:

1

0mod ( )

km t t k j t

k jj

x F x g x g x−

+ + +

=

= +∑ (4.35)

Tabla 4.4: Algoritmo de multiplicación MSD en GF(2m)

Entrada: 1 1

0 0( ) , ( ) ( )

m ni wi

i ii i

A x a x B x B x x− −

= =

= =∑ ∑

Salida: 1

0( ) ( )· ( )

mi

ii

R x A x B x r x−

=

= =∑

( ) 0 1 donwto 0

C xfor i n

== −

( ) ( ) ( ) ( )

( ) ( ) mod ( )i

n

C x B x A x C x

A x A x x F x

= ⋅ +

= ⋅

( ) ( )mod ( )R x C x F x=

CAPÍTULO 4

95

Teorema 2. En un multiplicador de dígitos que posea un tamaño de dígito D, con D m k≤ − , los resultados intermedios del algoritmo de la tabla 4.4 pueden reducirse a un grado menor que m en un solo paso.

Estos dos teoremas nos están indicando implícitamente que para un

polinomio dado 1

0( )

km k j

k jj

F x x g x g x−

=

= + +∑ , el tamaño D del dígito debe

elegirse basándose en el valor de k, el valor del segundo mayor grado del polinomio irreducible.

4.4.3 PROPUESTA DE MULTIPLICADOR DE DÍGITOS EN SERIE EN

GF(2M)

La ecuación (4.34) está compuesta por una serie de sumandos que en su conjunto nos permitirán obtener la multiplicación modular. Si atendemos a cada uno de ellos vemos que son de la forma:

( )· ( ) mod ( )wjA x B x x f x (4.36)

A su vez, el número A(x) puede ser descompuesto en n dígitos de la misma forma que lo hemos hecho para B(x), y por lo tanto podemos expresar la ecuación (4.36) como:

( )1

1

0

( )· ( ) mod ( ) ( ) ( )· mod ( )·n

w iwj j i

i

A x B x x f x B x A x x f x−

+

=

= = ∑ (4.37)

( ) ( )2

11

0

( )· ( )· mod ( ) ( )· ( )·n

w iwnj n j i

i

B x A x x f x B x A x x−

+−

=

= + ∑ (4.38)

Y aquí:

( ) ( )1 2

11

0 0

( )· ( )· ( )· ( )· ( )·m n

w iw wii n i j i

i i

B x A x x F x x B x A x x− −

+−

= =

+∑ ∑ (4.39)

Que será la expresión que debemos calcular para obtener cada uno de los sumandos que componen el producto.

Veamos de forma gráfica cómo realizaremos esta operación. Para ello, supongamos que los elementos que forman parte de ella están compuestos por tres dígitos:


96

A(x) = A2(x)A1(x)A0(x), B(x) = B2(x)B1(x)B0(x) y F(x) = F2(x)F1(x)F0(x)

Y que a su vez, cada dígito D está compuesto por cuatro bits:

Di(x) =d3d2d1d0

Multipliquemos A(x) por B(x). Puesto que se trata de un multiplicador de dígitos en paralelo, multiplicar dos dígitos implicará multiplicar en cada paso los bits que componen cada uno de ellos. Como vamos a utilizar el esquema MSD empezaremos multiplicando los bits de A2 de forma sucesiva por los de B2, B1 y B0.

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

■ ■ ■ ■

■ ■ ■ ■

■ ■ ■ ■

■ ■ ■ ■

● ● ● ● ● ● ●

Figura 4.8 - Multiplicación de los bits de A2 por los de B2

Como ya sabemos, si A2 y B2 están compuestos por n bits, su producto nos proporciona un resultado que tendrá 2n–1 bits que podemos descomponer en dos partes: una alta compuesta por n–1 bits y otra baja compuesta por n bits.

Cuando multipliquemos A2 y B1 tendremos un resultado similar y, como vemos en la figura, tendremos que sumar su parte alta con la parte baja del producto de A2 y B2 para ir componiendo el resultado de forma correcta.

CAPÍTULO 4

97

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■

● ● ● ● ● ● ● ● ● ● ●

Figura 4.9 - Multiplicación de los bits de A2 por los de B1

Lo mismo ocurrirá cuando multipliquemos A2 por B0.

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

s32 s31 s30 s23 s22 s21 s20 s13 s12 s11 s10 s03 s02 s01 r00

Figura 4.10 - Obtención del producto a A3 por B

Y así finalmente obtenemos el producto de A3 por B. Por supuesto, este resultado debe reducirse a módulo F(x). Para ello bastará que cojamos la parte alta del producto de A2 por B2 la multipliquemos por el polinomio reductor y se la sumemos al resultado parcial que tenemos. Si hemos elegido


98

de forma correcta el número de bits que componen cada dígito, esta reducción se realizará en un solo paso [9, 66].

f23 f22 f21 f20 f13 f12 f11 f10 f03 f02 f01 f00

× s32 s31 s30

s’23 s’22 s’21 s’20 s’13 s’12 s’11 s’10 s’03 s’02 s’01 s’00

s23 s22 s21 s20 s13 s12 s11 s10 s03 s02 s01 s00

s’23 s’22 s’21 s’20 s’13 s’12 s’11 s’10 s’03 s’02 s’01 s’00

S23 S22 S21 S20 S13 S12 S11 S10 S03 S02 S01 S00

+

Figura 4.11 - Reducción del producto de A3 por B

Puesto que los valores de s32, s31 y s30 los tenemos después de realizar el primer producto, los diferentes valores de S’ los podemos ir obteniendo simultáneamente con los productos de A3 por Bi. Por tanto, ya tenemos el producto reducido de A2 por B.

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

S23 S22 S21 S20 S13 S12 S11 S10 S03 S02 S01 S00

Figura 4.12 – Producto reducido de A3 por B

CAPÍTULO 4

99

Ahora tendremos que repetir la misma estrategia anterior para obtener A2 por B y sumarle el resultado parcial que tenemos hasta este momento.

B2 ×

A2*B2 = sH,sL +

A2*B1 +

F1 * sH

sH ← Es la parte alta del producto

A2*B2

B1 B0

S2 S1

S0

F2 * sH

A2*B0

F0 * sH

+

+

+

Estos dos productos se pueden realizar

simultáneamente

Figura 4.13 – Producto de A2 × B


100

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

S23 S22 S21 S20 S13 S12 S11 S10 S03 S02 S01 S00

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

t33 t32 t31 t30 t23 t22 t21 t20 t13 t12 t11 t10 t03 t02 t01 t00

Figura 4.14 – Producto de A1 por B

Y multiplicando t33, t32, t31, t30 por el polinomio reductor y sumándolo sobre el resultado parcial, tendremos el producto acumulado de los dos primeros dígitos de A por B. La reducción la podemos hacer de forma intercalada.

f23 f22 f21 f20 f13 f12 f11 f10 f03 f02 f01 f00

× t33 t32 t31 t30

t’23 t’22 t’21 t’20 t’13 t’12 t’11 t’10 t’03 t’02 t’01 t’00

+t23 t22 t21 t20 t13 t12 t11 t10 t03 t02 t01 t00

t’23 t’22 t’21 t’20 t’13 t’12 t’11 t’10 t’03 t’02 t’01 t’00

T23 T22 T21 T20 T13 T12 T11 T10 T03 T02 T01 T00

Figura 4.15 – Producto acumulado reducido de los dos primeros dígitos

CAPÍTULO 4

101

Por tanto, ya tenemos el producto reducido de (A2, A1) por B. Situémoslo en la tabla para continuar con el último dígito (figura 4.17).

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

T23 T22 T21 T20 T13 T12 T11 T10 T03 T02 T01 T00

Figura 4.17 - Ubicación del producto de A1 y A2 por B

Y finalmente, procediendo de la misma forma para el producto A0 por B:

B2 ×

A1*B2 +

A1*B1 +

F1 * tH

B1 B0

S2 S1

S0

F2 * tH

A1*B0

F0 * tH

+

+ +

Resultado tras reducir el producto

A2*B

tH,tL sH ← Es la parte alta del producto

A1*B2 sumada a S2

T2 T1

T0


A1


102

b23 b22 b21 b20 b13 b12 b11 b10 b03 b02 b01 b00

a23 a22 a21 a20 a13 a12 a11 a10 a03 a02 a01 a00

T23 T22 T21 T20 T13 T12 T11 T10 T03 T02 T01 T00

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●

r33 r32 r31 r30 r23 r22 r21 r20 r13 r12 r11 r10 r03 r02 r01 r00

Figura 4.18 – Producto de A por B previo a la reducción final

Multiplicando r33, r32, r31, r30 por el polinomio reductor y sumándolo sobre el resultado parcial, tendremos el producto de A por B que estábamos buscando. La reducción la podemos hacer de forma intercalada.

f23 f22 f21 f20 f13 f12 f11 f10 f03 f02 f01 f00

× r33 r32 r31 r30

r’23 r’22 r’21 r’20 r’13 r’12 r’11 r’10 r’03 r’02 r’01 r’00

r23 r22 r21 r20 r13 r12 r11 r10 r03 r02 r01 r00

r’23 r’22 r’21 r’20 r’13 r’12 r’11 r’10 r’03 r’02 r’01 r’00

R23 R22 R21 R20 R13 R12 R11 R10 R03 R02 R01 R00

+

Figura 4.19 – Última reducción y obtención del resultado final

CAPÍTULO 4

103

En forma algorítmica, este producto con reducción intercalada presenta la forma que se presenta en la tabla 4.5:

B2 ×

A0*B2 +

A0*B1 +

F1 * rH

B1 B0

T2 T1

T0

F2 * rH

A0*B0

F0 * rH

+

+ +

Resultado tras reducir el producto

(A2,A1)*B

rH,rL sH ← Es la parte alta del producto

A0*B2 sumada a T2

R2 R1

R0

A0



104

Tabla 4.5: Algoritmo de multiplicación con reducción intercalada

Entrada: m: tamaño en bits del campo en que vamos a trabajar w: tamaño de palabra elegido s: número de palabras ( / )s m w=

( )1 2 0( ) , , , s sA x aa a− −= … , ( )1 2 0( ) , , , s sB x bb b− −= … , ( )1 2 0( ) , , , s sF x ff f− −= … Salida:

( ) ( )· ( ) mod ( )R x A x B x F x= , donde ( )1 2 0( ) , , , s sR x r r r− −= …

Paso 1: ( ) 0; ( ) 0; ( ) 0C x E x R x= = = Paso 2: for (i = s – 1; i ≥ 0; i = i – 1) { Paso 3: [ ] [ ]1 11,0 ( ) ( )· ( )· ( )w

s i sX x r x x a x b x− −= +

Paso 4: [ ]1( ) ( )E x X x=

Paso 5: [ ] [ ] 11,0 1,0( ) ( ) ( )· ( ) ( )· wsT x X x F x E x C x x− = + +

Paso 6: 0( ) ( )C x T x= Paso 7: for (j = s – 2; j ≥ 0; j = j – 1) { Paso 8: [ ]1,0 ( ) ( )· ( )· ( )w

j i jX x r x x a x b x = +

Paso 9: [ ] [ ]1,0 1,0( ) ( ) ( )· ( ) ( )· wjT x X x f x E x C x x = + +

Paso 10: 1 1( ) ( )jr x T x+ =

Paso 11: 0( ) ( )C x T x= Paso 12 } Paso 13: 0( ) ( )r x C x= Paso 14: }

CAPÍTULO 4

105

Mu

lt 1

X

H

X

L

Mu

lt 2

E

A

B

F

C

T

H

T

L

Ri R

i-1R

i-2 …

…

…

Figura 4.21 – Diagrama de bloques del multiplicador con reducción intercalada

EJEMPLO DEL ALGORITMO DE MULTIPLICACIÓN PROPUESTO

En este ejemplo utilizaremos ( ) 16 5 3 1f x x x x x= + + + + sobre GF(216), con

datos estructurados en palabras de cuatro bits (s = 4). Por tanto, la multiplicación de 16×16 bits se realizará mediante productos parciales de 4 palabras de 4 bits.


106

Sea, por ejemplo:

A = (a3, a2, a1, a0) = (0010, 0001, 0010, 0111) = (2 1 2 7)

B = (b3, b2, b1, b0) = (0101, 0010, 0011, 1000) = (5 2 3 8)

F = (10000000000101011) por lo que:

(f3, f2, f1, f0) = (0000, 0000, 0010, 1011) = (0 0 2 B)

Para mayor simplicidad partiremos de i = 0, por lo que solo consideraremos del paso 2 en adelante. En consecuencia tendremos que C, E y r ya se encuentran inicializados y con los contenidos para los valores previos de i.

Paso 2: i = 0

Paso 3: X[1,0] = r3 · 4x + a0 · b3 = E0 + 7 · 5 = E0 + 1B = FB

Paso 4: E = X[1] = F

Paso 5: T[1,0] = X[1,0] + (f3 · E + C · 4 x ) = FB + (0 · F + B0) = 4B

Paso 6: C = T[0] = B

Paso 7: j = 2

Paso 8: X[1,0] = r2 · 4x + a0 · b2 = 70 + 7 · 2 = 70 + 0E = 7E

Paso 9: T[1,0] = X[1,0] + (f2 · E + C · 4x ) = 7E + (0 · F + B0) = CE

Paso 10: r3 = T[1] = C

Paso 11: C = T[0] = E

Paso 7: j = 1

Paso 8: X[1,0] = r1 · 4x + a0 · b1 = 30 + 7 · 3 = 30 + 09 = 39

Paso 9: T[1,0] = X[1,0] + (f1 · E + C · 4x ) = 39 + (2 · F + E0) = C7

Paso 10: r2 = T[1] = C

Paso 11: C = T[0] = 7

Paso 7: j = 0

Paso 8: X[1,0] = r0 · 4x + a0 · b0 = 70 + 7 · 8 = B0 + 38 = 88

CAPÍTULO 4

107

Paso 9: T[1,0] = X[1,0] + (f0 · E + C · 4x ) = 88 + (B · F + 70) = 91

Paso 10: r1 = T[1] = 9

Paso 11: C = T[0] = 1

Paso 13 r0 = C = 1

Con estos cálculos tenemos que R = (r3, r2, r1, r0) = (C C 9 1) = (1100 1100 1001 0001).

Fácilmente podemos comprobar que la multiplicación de 2127×5238 mod 1002B proporciona como resultado CC91.

GENERALIZACIÓN DEL ALGORITMO DE MULTIPLICACIÓN PROPUESTO

En el algoritmo anterior hemos asumido que el tamaño del campo m–1 es un múltiplo del tamaño de palabra w. Al hacerlo así, tras el paso 3 del algoritmo anterior [ ] [ ]( )1 11,0 ( ) ( ) ( )· ( ,)·w

s i sX r xx x a bx x− −= + la parte alta de X (X[1])

siempre contendrá los bits que deben ser reducidos.

Ahora discutiremos el caso en que no tengamos un valor de m múltiplo de w. Es decir, que m tenga un número arbitrario de bits.

Puesto que tenemos una estructura operativa, mantendremos el mismo esquema e iremos introduciendo las modificaciones oportunas para que el funcionamiento siga siendo correcto.

Si seguimos manteniendo el tamaño de palabra en w bits, el número de palabras de que dispondremos ahora será ( )/s m w= . Por tanto, los

( · )s w m− bits más significativos estarán compuestos por ceros.

Cuando ahora hagamos [ ] [ ]( )1 11,0 ( ) ( ) ( )· ( ,)·ws i sX r xx x a bx x− −= + los bits que

deben ser reducidos ya no estarán únicamente en X[1], sino que también deben incluirse los ( · )s w m− bits más significativos de X[0]. Si desplazamos


108

a la izquierda esos bits hasta que queden integrados en X[1], el funcionamiento será el mismo que describimos antes.

Mu

lt 1

XH

X

L

Mu

lt 2

Ei

A

B

F

C

T H

T L

Ri R

i-1R

i-2

… …

…

AN

D2

A

ND

1

Ef

Figura 4.22 – Diagrama de bloques del multiplicador generalizado

CAPÍTULO 4

109

Tabla 4.6: Algoritmo de multiplicación generalizado

Entrada: m: tamaño en bits del campo en que vamos a trabajar w: tamaño de palabra elegido s: número de palabras ( / )s m w=

( )1 2 0( ) , , , s sA x aa a− −= … , ( )1 2 0( ) , , , s sB x bb b− −= … , ( )1 2 0( ) , , , s sF x ff f− −= …( )

1 2 1w sw mK − −= − , 2 ( )2 2 1w sw mK − −= −

Salida: ( ) ( )· ( ) mod ( )R x A x B x F x= , donde ( )1 2 0( ) , , , s sR x r r r− −= …

Paso 1: ( ) 0; ( ) 0; ( ) 0C x E x R x= = = Paso 2: for (i = s – 1; i ≥ 0; i = i – 1) { Paso 3a: [ ] [ ]1 11,0 ( ) ( )· ( )· ( )w

s i siX x r x x a x b x− −= +

Paso 3b: [ ] [ ] [ ] [ ] 11 1 0 0( ) ; ( ) ( )f i f iX x X X x X x K= = ∧

Paso 3c: [ ] [ ]1,0 1,0( ) ( )· sw mi iX x X x x −=

Paso 4: [ ]1( ) ( )i iE x X x=

Paso 5: [ ] [ ] 11,0 1,0( ) ( ) ( )· ( ) ( )· ws ffT x X x F x E x C x x− = + +

Paso 6: 0( ) ( )C x T x=

Paso 7a: [ ] [ ]2 21,0 ( ) ( )· ( )· ( )ws i siX x r x x a x b x− −= +

Paso 7b: [ ] [ ] 21,0 1,0( ) ( )f iX x X x K= ∧

Paso 7c: [ ] [ ]( )

1 1( ) ( )· w sw mi iX x X x x− + −=

Paso 8: [ ]1( ) ( ) ( )f i iE x E x X x= +

Paso 9: [ ] [ ] 21,0 1,0( ) ( ) ( )· ( ) ( )· ws ffT x X x F x E x C x x− = + +

Paso 10: 1 1( ) ( )sr x T x− = ; 0( ) ( )C x T x= Paso 11: for (j = s – 3; j ≥ 0; j = j – 1) { Paso 12: [ ]1,0 ( ) ( )· ( )· ( )w

j i jfX x r x x a x b x = +

Paso 13: [ ] [ ]1,0 1,0( ) ( ) ( )· ( ) ( )· wjfT x X x f x E x C x x = + +

Paso 14: 1 1( ) ( )jr x T x+ = ; 0( ) ( )C x T x= }

Paso 15: 0( ) ( )r x C x= }


110

La frecuencia máxima de funcionamiento del circuito quedará establecida por el elemento que determine el camino crítico, que en este caso claramente será el circuito multiplicador. Si utilizamos un multiplicador paralelo del tipo descrito en el punto 4.4.1 compuesto internamente a su vez por otros del mismo tipo hasta tomar como base un pequeño multiplicador típico de n bits compuesto por n2 puertas AND y (n–1) puertas XOR , el número de puertas que compondrán un multiplicador de m bits será:

(log )

(log )

#

# ( ) ( )

−

−

⋅

⋅ − + −

1 2

1 2

puertas AND: 3

puertas XOR: 3 1

2 4

n

n

m

m mnn

(4.40)

Lo que significa que si el multiplicador básico está compuesto por 4 bits el retardo introducido por el multiplicador de m bits será:

∆ = ⋅∆ + + − ⋅∆4 24 [3 (log ) 1]Mult AND XORT T m T (4.41)

Si observamos el diagrama de bloques de la figura 5.16, el camino crítico incorpora, además el multiplicador, un grupo de puertas XOR y otro de puertas AND. Por tanto, el retardo del camino crítico es:

25 [4 (log ) 1]M AND XORT T m T∆ = ⋅∆ + + − ⋅∆ (4.42)

En consecuencia, para el modelado del criptoprocesador optaremos por este multiplicador un tamaño de palabra de 32 bits. El tiempo de latencia será el establecido en la ecuación (4.42) y será función del campo en que estemos trabajando.

4.4.4 CUADRADO

El cuadrado de un elemento A(x)∈GF(2m) se puede implementar de forma sencilla intercalando ceros entre los bits que conforman su representación :

12 2

02( 1) 2( 2) 2

1 2 1 0

( )m

ii

im m

m m

A x a x

a x a x a x a

−

=− −

− −

= =

= + + + +

∑

(4.43)

Con lo que tendremos un valor compuesto por el doble de bits de los que tenía A(x) y que requerirá su posterior reducción a grado m.

CAPÍTULO 4

111

En hardware estos dos pasos pueden combinarse fácilmente si el polinomio reductor tiene un número pequeño de coeficientes no nulos, como es el caso de los trinomios y pentanomios irreducibles. En este caso, la arquitectura que se encargue de realizar la elevación al cuadrado se puede presentar como un circuito compuesto únicamente por puertas XOR que nos proporcionará el resultado en un único ciclo de reloj sin grandes requisitos de espacio, si bien la reducción se realiza para un polinomio único. La figura 4.33 muestra un ejemplo de cómo sería para 163 7 6 3( ) 1f x x x x x= + + + + .

En primer lugar realizaremos la expansión del polinomio inicial, que a nivel hardware no presenta coste alguno puesto que solo consistirá en introducir ceros entre los valores ya existentes en el bus hasta obtener un tamaño de 2n bits.

A continuación realizamos la reducción, que no resultará en absoluto costosa. Primero porque el polinomio reductor es un pentanomio y en segundo lugar porque el número de bits a reducir es muy pequeño, ya que no se requerirá para los 2n bits de orden superior.

A(x) a[162..0]

a 0

a 160

a 160

a 1

62

a 1

a 161

a 160

a 1

61

a 160

a 2

a 82

a 83

a 82

b 0

b 1

b 2

b 3

b 4

B(x)=A2(x) mod f(x)

b[162..0]

Figura 4.23 – Circuito para la obtención del cuadrado en GF(2163)

a 159

a 1

62

a 161

a 81

a 159

b 161

b 162


112

El problema que nos encontramos es que cada circuito es específico para cada valor de m, por lo que si el valor del campo es seleccionable no podremos recurrir a esta configuración. La operación de elevación al cuadrado la implementaremos haciendo uso del multiplicador.

4.4.5 INVERSIÓN

Como ya discutimos en el capítulo 2, existen varias técnicas que nos permiten realizar la inversión. El método de Itoh y Tsujii [10], basado en el pequeño teorema de Fermat, utiliza cadenas aditivas que hacen que la inversión se pueda realizar mediante sucesivas elevaciones al cuadrado y multiplicaciones. Este método resulta particularmente adecuado cuando se trabaja en un campo específico y se dispone de un circuito hardware dedicado para la elevación al cuadrado, pues solo se requerirá para ello un solo ciclo de reloj. Si el número de ciclos necesario para realizar las multiplicaciones es menor que el que emplea un circuito inversor, estaría justificado su uso.

Figura 4.24 – Estructura del inversor utilizado

P2

P1 B1

>>1

B2

0 0

1 >>1

Resultado

a f

CAPÍTULO 4

113

Sin embargo, la implementación en hardware del algoritmo extendido de Euclides y sus posibles modificaciones (descritos en las tablas 2.8-10) resultan lo suficientemente simples y eficientes [71] para decantarnos sin duda por su utilización. En concreto hemos implementado el algoritmo casi inverso modificado de la tabla 2.10 siguiendo una estructura similar a la que muestra la figura 4.24.

Este tipo de inversor posee un tiempo de latencia variable, pues depende de los datos. Su valor tiende a 2m ciclos de reloj y en ningún caso supera los 3m. Valores muy inferiores a los requeridos al utilizar el método itoh-Tsujii que, por ejemplo, para un campo m = 163 necesitaría 171 producto y 18639 ciclos de reloj frente a los 489 que, en el peor de los casos, podríamos llegar a emplear con el algoritmo casi inverso modificado.

4.4.6 DIVISIÓN

La división no requiere la implementación de un circuito hardware específico, ya que la descompondremos operaciones ya implementadas: una inversión y una multiplicación. La instrucción de división está constituida por la secuencia que nos muestra la tabla 4.7.

Tabla 4.7: Secuencia de operaciones para la división.

Entradas: A: registro que contiene el divisor (x1) B: registro que contiene el dividendo (x2)

Salida: D: registro que contiene el resultado (x2/ x1)

1. 1

1Ax

←

2. 2B x←

3. 2

1

xD

x←


114

4.4.7 SUMA DE DOS PUNTOS DE UNA CURVA ELÍPTICA

La suma de dos puntos de una curva elíptica está basado en el algoritmo que se muestra en la tabla 2.12 para el caso de que ambos puntos no sean iguales. Por tanto, utilizaremos las operaciones básicas ya implementadas de suma, multiplicación e inversión.

Inicialmente comprobaremos que el valor de las coordenada x de ambos puntos son un valor distinto de cero, pues si lo fuera en alguno de ellos nos

Tabla 4.8: Secuencia de operaciones para la suma de puntos de la curva

Entradas: registros que contienen la coordenada x del primer punto (x1, y1) registros que contienen la coordenada x del segundo punto (x2, y2) Salida: Z: registros que contienen el resultado (x3, y3) = (x1, y1) + (x2, y2) 1. If (x1, y1)= 0 then then return Z = (x2, y2) and stop. 2. If (x2, y2)= 0 then then return Z = (x1, y1) and stop. else 3. 1 2( )S x x← +

4. 1 2

1Ax x

←+

5. 1 2( )B y y← +

6. 1 2

1 2

y yD

x xλ

+← =

+

7. S λ← 8. 2D λ← 9. 2

0Z λ λ← +

10. 20 1Z xλ λ← + +

11. 20 1 2Z x xλ λ← + + +

12. 20 1 2 3Z x x a xλ λ← + + + + =

13. 1 3( )A x x← + 14. 1 3( )D x xλ← + 15. 1 1 3 3( )Z x x xλ← + + 16. 1 3 3 1 31 ( )Z x x x y yλ← + + + =

CAPÍTULO 4

115

estaría indicando de que se trata de un punto al infinito que se codifica como (0,0) y en ese caso el resultado estaría compuesto por el otro.

Todos los puntos de la curva elíptica necesitan ser almacenados en un par de registros, por lo que solo es necesario indicar la ubicación de la coordenada x para que quede especificado el lugar de destino.

La secuencia de instrucciones implementada para la realización de la suma de dos puntos de la curva elíptica es la que se muestra en la tabla 4.8.

4.4.8 DUPLICADO DE UN PUNTO DE UNA CURVA ELÍPTICA

El duplicado de un punto de una curva elíptica (es decir, la suma de un punto consigo mismo) está basado en el algoritmo que se muestra en la tabla 2.12 para el caso en que los puntos a sumar sean coincidentes. En consecuencia nuevamente utilizaremos las operaciones básicas ya implementadas de

Tabla 4.9: Secuencia de operaciones para el duplicado de un punto de la curva.

Entradas: registros que contiene la coordenadas del punto (x1, y1) Salida: Z, registros que contienen el resultado (x3, y3) = (x1, y1) + (x1, y1)

1. If (x1, y1)= 0 then then return Z = (x1, y1) and stop.else

2. ← ← ←11

1 1

1; ( ; )x

D A B xy y

3. λ← + =11

1

xS x

y

4. λ← 2D5. λ λ← +2D

6. 20 3Z a xλ λ← + + =

7. 1 3( )A x x← +

8. 1 3( )D x xλ← + 9. 1 1 3 3( )Z x x xλ← + + 10. 1 1 3 3 1 3( )Z x x x y yλ← + + + =


116

suma y multiplicación y la operación compuesta de división. Inicialmente comprobaremos que la coordenada x del punto a duplicar sea un valor distinto de cero, pues si lo fuera se trataría del punto al infinito, que se codifica como (0,0), y el resultado sería el propio punto al infinito. Todos los puntos de la curca elíptica necesitan ser almacenados en un par de registros, por lo que solo es necesario indicar la ubicación de la coordenada x para que quede especificado el lugar de destino.

La secuencia de instrucciones implementada para la realización de la suma de dos puntos de la curva elíptica es la que se muestra en la tabla 4.9.

4.5 DESCRIPCIÓN DEL FORMATO DE INSTRUCCIÓN Dadas las operaciones a realizar y el número de registros necesarios, el formato general de las instrucciones es el que se presenta en la figura 4.23.

Cod_Ope rd rf1 rf015 12 11 8 7 4 3 0

Figura 4.25 – Formato General de las instrucciones

De los cuatro campos que disponemos, Cod_Ope será el Código de Operación que diferenciará cada una de las instrucciones. Los otros tres campos hacen referencia, en general, a los registros implicados en la operación seleccionada, excepto en las instrucciones de salto en las que conjuntamente formarán el desplazamiento que se debe realizar.

Disponemos de varios tipos de registros:

Un banco de ocho registros de propósito general, referido de forma global como R[7:0], y de cada registro de forma individual como R seguida del índice del registro seleccionado.

Dos registros de entrada del multiplicador (A, B). Aunque son fijos para este operador, pueden ser utilizados por el resto.

Un registro de salida del multiplicador (D). Aunque es fijo para este operador, puede ser utilizado por el resto sin ninguna limitación.

Un registro específico (F) que contendrá el campo en el que se va a trabajar.

Un registro de operación para el almacenamiento temporal (S).

CAPÍTULO 4

117

Adicionalmente, también se incluye en estos campos la codificación de una constante, correspondiente al 0 que se incorpora en rf1.

La codificación correspondiente a estos tres campos es la que se muestra en la tabla 4.10.

Las instrucciones implementadas son las siguientes:

• Suma (ADDGF)• Multiplicación (MULGF)• Inversión (INVGF)• Cuadrado (SQGF)• División (DIVGF)• Establecimiento del campo de trabajo (SETGF)• Duplicado de un punto de una curva elíptica (DUPEC)• Suma de dos puntos de una curva elíptica (ADDEC)• Copia del contenido de registros (MOV)• Carga externa datos a un registro (LOAD)• Transferencia externa de los datos de un registro (ULOAD)• Comparación del contenido de dos registros (COMP)• Salto incondicional (JMP)• Salto condicional (JZ)

La descripción detallada de las instrucciones está realizada en el punto siguiente.

Tabla 4.10: Tipo de Registro y codificación utilizada.

Registro Codificación R[7:0] 0XXX

A 1001 B 1010

T (A, B) 1011 D 1100 S 1101 F 1110 0 1000


118

4.6 DESCRIPCIÓN DETALLADA DE LAS INSTRUCCIONES A continuación se describen de forma detallada las diferentes instrucciones que se han implementado y que se han utilizado en el punto anterior para la realización de las operaciones necesarias para trabajar con una curva elíptica.

ADDGF rd, rf1, rf0

Esta instrucción realiza la suma de los contenidos de los registros rf1 y rf0 y deja el resultado en registro rd. La operación se realiza en el campo GF(2m) definido por el valor de m almacenado en el registro F.

Esta operación es equivalente a 1 0rd rf rf= ⊕ .

1 0rd rf rf← +

Los registros que pueden utilizarse son:

rd: R[7:0], A, B, S, D rf0: R[7:0], A, B, S, D rf1: R[7:0], A, B, S, D

0 0 0 0 rd rf1 rf015 12 11 8 7 4 3 0

Figura 4.26 - Formato de la instrucción de Suma

MULGF

Esta instrucción multiplica el contenido del registro A por el contenido del registro en el en el campo GF(2m) definido por el valor de m almacenado en el registro F, quedando el resultado en el registro D.

← D A B

Los registros no admiten configuración.

CAPÍTULO 4

119

0 0 0 115 12 11 8 7 4 3 0

Figura 4.27 - Formato de la instrucción de Multiplicación

INVGF rd, rf

Esta instrucción realiza en inverso del contenido del registro rf en el en el campo GF(2m), definido por el valor de m almacenado en el registro F, y deja el resultado en el registro rd.

rd: R[7:0], A, B, D rf: R[7:0], A, B, D

←1rdrf

rd y rf no pueden coindicir.

0 0 1 0 rd rf15 12 11 8 7 4 3 0

Figura 4.28 - Formato de la instrucción de Inversión

SQGF rf

Esta instrucción realiza el cuadrado del contenido del registro rf, en el en el campo GF(2m) definido por el valor de m almacenado en el registro F, dejando el resultado en el registro D.

rf: R[7:0], A, B, S

2D rf←


120

0 0 1 1 rf15 12 11 8 7 4 3 0

Figura 4.29 - Formato de la instrucción del Cuadrado

La instrucción SQGF es de segundo nivel y se puede descomponer en las siguientes:

MOV T, rf MULGF DIVGF rf0,rf1

Esta instrucción divide el contenido del registro rf0 entre el contenido del registro rf1, en el en el campo GF(2m) definido por el valor de m almacenado en el registro F, y deja el resultado en el registro D.

rf0: R[7:0] rf1: R[7:0]

01

rfDrf

←

0 1 0 0 rf1 rf015 12 11 8 7 4 3 0

Figura 4.30 - Formato de la instrucción de División

SETGF rf

Esta instrucción carga en el registro F el valor definido en el registro rf estableciendo el campo trabajo GF(2m).

rf: R[7:0]

CAPÍTULO 4

121

←F rf

0 1 0 1 1 1 0 0 rf15 12 11 8 7 4 3 0

Figura 4.31 - Formato de la instrucción de Establecimiento de Campo

Esta instrucción es una situación particular de la instrucción MOV, por lo que comparte código de operación.

DUPEC rd, rf

Esta instrucción duplica (suma consigo mismo) el punto de la curva elíptica contenido en los registros consecutivos rf (coordenada x1) y rf+1 (coordenada y1). El parámetro a de la curva debe encontrarse en el registro R7. El resultado queda almacenado en los registros rd (coordenada x3) y rd+1 (coordenada y3).

rf: R[5:0] rd: R[5:0]

+ ← ( , 1) 2 ( , +1)rd rd rf rf

Los registros que constituyen rf, rf+1 y rd, rd+1 no pueden coincidir.

0 1 1 0 rd rf15 12 11 8 7 4 3 0

Figura 4.32 - Formato de la instrucción de Duplicado de un punto de la curva elíptica

Es una instrucción de segundo nivel y puede descomponerse en las instrucciones que nos muestra la tabla 4.11.


122

ADDEC rd0, rf0, rf1

Esta instrucción suma el punto de la curva elíptica contenido en los registros consecutivos rf0 (coordenada x1) y rf0+1 (coordenada y1) con el punto contenido en los registros rf1 (coordenada x2) y rf1+1 (coordenada y2). El parámetro a de la curva debe encontrarse en el registro R7. El resultado queda almacenado en los registros rd (coordenada x3) y rd+1 (coordenada y3).

Tabla 4.11: Secuencia de instrucciones para el duplicado de un punto de la curva.

Entradas: rf0: registro que contiene la coordenada x del punto (x1, y1) Salida: rd0, rd0+1: registros que contienen el resultado (x1, y1) + (x1, y1) COMP 0, rf0 1 0?x = JZ P1cero

DIVGF rf0, rf1 ← ← ←11

1 1

1; ( ; )x

D A B xy y

ADDGF S, B, D λ← + =11

1

xS x

y

SQGF S λ← 2D ADDGF D, D, S λ λ← +2D ADDGF rd, D, R7 2

3rd a xλ λ← + + = ADDFG A, rf, rd 1 3( )A x x← + MULGF 1 3( )D x xλ← + ADDGF rd+1, D, rd 1 3 3+1 ( )rd x x xλ← + + ADDGF rd+1, rd+1, rf+1 1 3 3 1 3+1 ( )rd x x x y yλ← + + + = JMP FIN P1cero MOV rd0, rf0 10rd x← MOV rd1, rf0+1 10 1rd y+ ← FIN END

CAPÍTULO 4

123

Tabla 4.12: Secuencia de instrucciones para la suma de puntos de la curva

Entradas: rf0: registro que contiene la coordenada x del primer punto (x1, y1) rf1: registro que contiene la coordenada x del segundo punto (x2, y2)

Salida: rd0, rd0+1: registros que contienen el resultado (x1, y1) + (x2, y2)

COMP 0, rf0 1 0?x =

JZ P1cero

COMP 0, rf1 2 0?x =

JZ P2CERO ADDGF S, rf0, rf1 1 2( )S x x← +

INVGF A, S 1 2

1Ax x

←+

ADDGF B, rf0+1, rf1+1 1 2( )B y y← +

MULGF 1 2

1 2

y yD

x xλ

+← =

+

MOV S, D S λ← SQGF S 2D λ← ADDGF rd0, D, S 20rd λ λ← + ADDGF rd0, rd0, rf0 2

10rd xλ λ← + +

ADDGF rd0, rd0, rf1 21 20rd x xλ λ← + + +

ADDGF rd0, rd0, R7 21 2 30rd x x a xλ λ← + + + + =

ADDGF A, rd0, rf0 ← +1 3( )A x x MULGF 1 3( )D x xλ← + ADDGF rd0+1, D, rd0 1 3 30+1 ( )rd x x xλ← + + ADDGF rd0+1,rd0+1,rf+1 1 3 3 1 30+1 ( )rd x x x y yλ← + + + =

JMP FIN P1cero MOV rd0, rf1 20rd x←

MOV rd1, rf1+1 20 1rd y+ ← JMP FIN

P2cero MOV rd0, rf0 10rd x←

MOV rd1, rf0+1 10 1rd y+ ← FIN END


124

rf0: R[5:0] rf1: R[5:0] rd: R[5:0]

Los registros que constituyen rd no pueden coincidir ninguno de los que constituyen rf0 y rf1

( , 1) ( 0, 0+1) ( 1, 1+1)rd rd rf rf rf rf+ ← +

0 1 1 1 rd rf1 rf015 12 11 8 7 4 3 0

Figura 4.33 - Formato de la instrucción de Suma de dos puntos de la curva elíptica.

Es una instrucción de segundo nivel y puede descomponerse en las siguientes:

ADDGF S, rf0, rf1 1 2( )S x x← +

INVGF A, S 1 2

1Ax x

←+

ADDGF B, rf0+1, rf1+1 1 2( )B y y← + MOV rd, rf

Esta instrucción copia el contenido del registro rf en el registro rd.

rf: R[7:0], A, B, S, D rd: R[7:0], A, B, S

rd rf←

0 1 0 1 rd rf15 12 11 8 7 4 3 0

Figura 4.34 - Formato de la instrucción de Copia de contenido de un registro

CAPÍTULO 4

125

LOAD rd

Esta instrucción carga desde el exterior del chip el registro rd. La carga se realiza mediante accesos de 32 bits hasta completar la longitud total del registro empezando por su parte menos significativa.

rd: R[7:0], A, B, F

I/Ord ←

1 0 0 0 rd15 12 11 8 7 4 3 0

Figura 4.35 - Formato de la instrucción de Carga de datos

ULOAD rf

Esta información envía al exterior del chip el contenido del registro rf. La información se extrae en bloques de 32 bits empezando por su parte menos significativa.

rd: R[7:0], D

I/O rd←

1 0 0 1 rd15 12 11 8 7 4 3 0

Figura 4.36 - Formato de la instrucción de Transferencia de datos al exterior

COMP rf0, rf1

Esta instrucción compara el contenido de los registros rf0 y rf1 y activa un flag (Z) en el caso de que sean iguales.


126

rf0: R[7:0], A, B, S, D, Cero rf1: R[7:0], A, B, S, D, Cero

Si , 1Si , 0

rf fd Zrf fd Z

= ←≠ ←

1 0 1 0 rf1 rf015 12 11 8 7 4 3 0

Figura 4.37 - Formato de la instrucción de Comparación

JMP <desp>

Esta instrucción hace que se incremente el contenido del contador de programa (PC) la cantidad indicada por el campo <desp>.

PC PC desp← + < >

1 0 1 0 desp15 12 11 0

Figura 4.38 - Formato de la instrucción de Salto

JZ <desp>

Esta instrucción hace que se incremente el contenido del contador de programa (PC) la cantidad indicada por el campo <desp> en el caso de que el flag Z se encuentre a 1; en caso contrario no tiene efecto alguno.

Si 1, Z PC PC desp= ← + < >

1 0 1 1 desp15 12 11 0

Figura 4.39 - Formato de la instrucción de Salto Condicional

127

CAPÍTULO 5

EXPERIMENTOS. VALIDACIÓN DEL MODELO

Una vez realizada la descripción del algoritmo del multiplicador con reducción intercalada propuesto conjuntamente con su estructura, se hace necesario comprobar que cumple con los requisitos que se pretendían.

Para ello procedemos a realizar su implementación sobre un dispositivo real que nos permita cuantificar sus necesidades de espacio y podamos medir su respuesta temporal.

Posteriormente pasaremos a implementar el modelo de criptoprocesador propuesto. Primero modelaremos los diferentes bloques que lo componen de forma que podamos medir de forma individual sus requisitos espacio-temporales y a continuación integraremos todos los bloques y comprobaremos la bondad del sistema diseñado.


128

5.1 IMPLEMENTACIÓN DEL MULTIPLICADOR BÁSICO La implementación del multiplicador base que emplea, y del que necesitaremos dos unidades en el multiplicador con reducción intercalada propuesto, se ha llevado a cabo en un FPGA de Xilinx XC3S500E.

Para el sintetizado final del circuito se ha utilizado el paquete software ISE Design Suite 14.3 de Xilinx y, puesto que se trata de un circuito puramente combinacional, se realiza básicamente sobre LUT.

Cada una de ellas introduce un retardo de 0.612ns por cada nivel de utilización. En concreto, un multiplicador de 16 bits está compuesto por 5 niveles, por lo que tendrá a los un tiempo de respuesta de 3,68 ns. La tabla 5.1 nos muestra el retardo propio del multiplicador obtenido tras su implementación y la frecuencia máxima de operación de que admitiría.

El uso de un FPGA u otro va a determinar la frecuencia de funcionamiento de forma marcada. La utilización de un FPGA de la familia Virtex o Kintex haría que el tiempo de respuesta disminuyera considerablemente. Por ejemplo, una LUT de un FPGA de la familia Virtex presenta un retardo de 0,053 ns, por lo que el tiempo de para un elemento multiplicador de 64 bits, que es el de mayor tamaño de los considerados, apenas esté un poco por encima de los 4 ns.

Tabla 5.1: Tiempo de respuesta y frecuencia de funcionamiento del elemento multiplicador.

Nº de bits Tiempo de respuesta Frecuencia máxima 16 3.672 ns 272.33 MHz 32 4.896 ns 204.25 MHz 64 6.12 ns 163.4 MHz

Si analizamos los algoritmos de las tablas 4.5 o 4.6 podremos comprobar que necesitamos tres ciclos de reloj para obtener cada una de las palabras de n bits que forman parte del resultado final. Por tanto el tiempo de respuesta vendrá dado por la expresión:

23MR MT s T∆ = ⋅ ∆ (5.1)

donde MT∆ representa el retardo del multiplicador básico para la frecuencia y el tamaño de palabra elegido establecido en la ecuación (4.42), por lo que

CAPÍTULO 5

129

la expresión final en función del retardo introducido por el tipo de puertas será:

25 [4 (log ) 1]M AND XORT T m T∆ = ⋅∆ + + − ⋅∆ (5.2)

5.2 IMPLEMENTACIÓN DEL MULTIPLICADOR CON REDUCCIÓN

INTERCALADA

La implementación del circuito multiplicador con reducción intercalada completo propuesto para trabajar sobre los campos binarios propuestos por N.I.S.T. [72] nos proporciona la tabla 5.2. En ella, los tiempos proporcionadospor la ecuación (5.2) se ven ligeramente incrementados por la inclusión delos buffer que interconexión entre elementos en la FPGA.

0

1

2

3

4

5

6

7

8 bits 16 bits 32 bits 64 bits

Tiem

po d

e re

spue

sta

(ns)

Figura 5.1 – Tiempo de respuesta del multiplicador en función del número de bits


130

Tabla 5.2: Ciclos de reloj necesarios en el Multiplicador con Reducción Intercalada para los diferentes campos de trabajo y tamaño de palabra.

Tamaño de palabra Campo Nº de

palabras Ciclos de reloj Slices % de utilización

16

163 11 373 365 7 233 15 682 466 10 283 18 974 537 11 409 26 2029 711 15

32

163 6 109 823 17 233 8 193 846 17 283 9 244 865 18 409 13 508 961 20

64

163 3 28 2372 50 233 4 49 2380 52 283 5 76 2440 52 409 7 148 2470 53

Para un mismo tamaño de palabra, el índice de ocupación crece ligeramente debido al incremento del tamaño

0

500

1000

1500

2000

2500

163 233 283 409

Cicl

os d

e re

loj

16 bits 32 bits 64 bits

Figura 5.2 – Ciclos de reloj necesarios en el Multiplicador con Reducción Intercalada para los diferentes campos de trabajo y tamaño de palabra.

GF(2m)

CAPÍTULO 5

131

La figura 5.2 nos muestra los tiempos de respuesta de las implementaciones del Multiplicador con Reducción Intercalada en función del tamaño de

0

500

1000

1500

2000

2500

3000

163 233 283 409


0

2

4

6

8

10

12

14

163 233 283 409


Slices*s

GF(2m)

Slices

Figura 5.3 – Número de Slices utilizados en un FPGA Xilinx Spartan XC3S500E

Figura 5.4 – Producto ocupación*s para las diferentes implementaciones


132

palabra (w) elegido y para los diferentes campos de trabajo (m) recomendados por el N.I.S.T. Lógicamente, cuanto mayor es el tamaño de palabra más rápido es el multiplicador. Sin embargo, puesto que el multiplicador de 32 bits no presenta un número de palabras elevado, si el campo no es grande, los resultados no están muy alejados del multiplicador de 64 bits. Sin embargo si comparamos este multiplicador de 32 bits con el de 16, su mejora de tiempos es sustancial conforme vamos aumentando el campo de trabajo.

Por otra parte, si nos centramos en la cantidad de recursos consumidos del dispositivo sobre el que se implementan (figura 5.3), el área requerida por un multiplicador de 64 bits es sustancialmente superior a la de los otros dos. Ahora la curva correspondiente al multiplicador de 32 bits está más próxima a la proporcionada por el de 16 bits.

Si realizamos una tercera representación (figura 5.4) que nos relacione la ocupación y los tiempos de respuesta, comprobamos que la que mejor resultados proporciona es la correspondiente a la implementación con palabras de 64 bits, sin estar lejos la correspondiente a los 32 bits. La de 16 bits que si el campo es grande crece excesivamente.

Como conclusión tendremos que el uso de un multiplicador con reducción intercalada que utilice palabras de 64 bits será siempre el más adecuado si no tenemos ningún tipo de restricción de espacio. Su implementación sobre un FPGA Xilinx Spartan XC3S500E hace que se consuman en el mejor de los casos el 61% de sus recursos, por lo que el resto de elementos necesarios para operar sobre curvas elípticas tendrían difícil encaje; si bien es cierto que se trata de un chip de pequeño tamaño y podría considerarse la utilización de uno de mayor tamaño si fuera necesario.

En el extremo contrario tendríamos el multiplicador de 16 bits, que si bien la ocupación es aceptable, los retardos ya son más apreciables.

El multiplicador de 32 bits es el que proporciona una solución intermedia. Podemos observar que si bien se pueden mejorar sus datos tanto en espacio como en tiempo de respuesta, en ambos casos sus resultados no están excesivamente alejados del que mejor los presenta.

CAPÍTULO 5

133

5.3 IMPLEMENTACIÓN DEL MODELO DE CRIPTOPROCESADOR Basándonos en los criterios y operadores considerados hasta ahora, se ha implementado el procesador utilizando un FPGA de Xinlix Virtex XC675VLX75T para que sea capaz de trabajar en los diferentes propuestos en la tabla 6.1 hasta un valor de m = 409. El número de slices utilizados para cada componente se ve incrementado en el porcentaje de ocupación final por la lógica adicional necesaria para su interconexión.

Se ha establecido un tamaño de palabra de 32 bits, por lo que las diferencias entre las implementaciones son muy ligeras, pues solo diferirá en la cantidad de palabras con las que se debe operar.

El elemento clave en términos de ocupación es la ruta de datos descrita en la figura 4.4, pues será el elemento que mayor cantidad de recursos necesite. El multiplicador permanecerá invariable sea cual sea el campo de trabajo, pero no ocurrirá así con el resto de elementos. En cuanto a la unidad de control solo crece ligeramente conforme lo hace el campo. Los requisitos de espacio en el dispositivo obtenidos en función del valor del campo máximo en que se desee trabajar es el que nos muestra la tabla 5.3.

Tabla 5.3: Slices LUT de ocupación por parte de cada uno de los elementos en función del campo de trabajo (m)

m Función 113 131 163 193 233 283 409 Multiplic. 428 440 466 1556 823 2100 2380 Inversión 1028 1265 1511 1757 2004 2293 3299

Control 1474 1577 1734 1838 2022 2265 2518 Registros 1536 1920 2304 2688 3072 3456 4992

Suma 104 166 199 235 269 302 434

El banco de registros, al igual que los registros de uso específico, está

compuesto por un grupo de 8 registros de 32m

bits activos por flanco de

subida a los que se puede acceder en un solo ciclo de reloj. Cada uno de ellos está provisto de su propia señal de reloj y de reset, de forma que la señal de reloj será la que habilite la carga de uno u otro. Las salidas se encuentran


134

conectadas a un multiplexor que nos permitirá seleccionar mediante tres líneas la salida.

En esta implementación, la frecuencia de funcionamiento máxima queda establecida por componente que posea una mayor latencia, que sabemos que es el multiplicador y que quedaba establecida por la ecuación (5.2).

Para la comprobación del diseño realizado, se han realizado pruebas sobre diferentes puntos de una curva elíptica utilizando Modelsim [73] como simulador para los diferentes campos de trabajo posibles, proporcionándonos para las operaciones básicas de suma de dos puntos y del doblado de uno de ellos los resultados que muestra la tabla 5.4.

Los resultados están expresados en ciclos de reloj.

Tabla 5.4: Número de ciclos de reloj necesario para la ejecución de las operaciones en función del campo de trabajo (m)

m Operación 113 131 163 193 233 283 409

Suma 488 572 714 966 1114 1378 2433 Doblado 482 566 708 960 1110 1374 2429

En cuanto al producto escalar, la elección del algoritmo se centrará básicamente entre los algoritmos de Montgomery y el método binario clásico. Si tenemos en cuenta que la elevación al cuadrado la realizamos mediante el multiplicador, el algoritmo de Montgomery realiza en cada iteración 4 multiplicaciones, mientras que el método binario, como media realizará 6 multiplicaciones. Por contra, el método binario realiza en cada iteración una única inversión, mientras que el algoritmo de Montgomery realiza 2.

En consecuencia, la elección de un método u otro dependerá de la eficiencia con que se realice la inversión y la multiplicación. Si el tiempo de ejecución de una inversión es menor al de realización de dos multiplicaciones elegiremos el algoritmo de Montgomery. Sin embargo, pese a disponer de un inversor con una implementación hardware con muy buenos tiempos de ejecución, el multiplicador diseñado es lo suficiente eficiente para requerir menos de la mitad de tiempo para responder. Lo que nos lleva a la elección del método binario para la realización de la multiplicación escalar siempre

CAPÍTULO 5

135

que el campo sea pequeño. El algoritmo de Montgomery se vuelve más eficiente conforme crece el campo en que estemos trabajando.

Aunque las pruebas experimentales nos indican que la frecuencia de funcionamiento máxima se sitúa, en el peor de los casos, por encima de los 166 MHz, estableciendo una frecuencia de 150 MHz los resultados en términos de tiempo son los que nos muestra la tabla 5.5.

Tabla 5.5: Tiempos de ejecución del producto escalar (ms)

m Método 113 131 163 193 233 283 409 Binario 0,46 0,61 0,77 1,18 1,89 2,64 5,97

Montgomery 0,65 0,71 0,88 1,21 1,77 2,25 5,16

5.4 ANÁLISIS DE RESULTADOS Los resultados obtenidos para el producto escalar sitúan el tiempo de respuesta en todos los casos por debajo de 1 ms cuando se trabaja con campos GF(2163) por lo que, teniendo en cuenta el dispositivo empleado para la implementación, podemos concluir que mejoran a los existentes en la literatura de características similares.

La comparación de estos resultados no es una tarea sencilla, pues en las implementaciones existentes se emplean metodologías muy diferentes y son muy heterogéneas. Hemos de tener en cuenta para las comparaciones que la escalabilidad y la flexibilidad son siempre factores importantes, pues el hecho de utilizar un campo de trabajo fijo (o varios) hace que el hardware necesario disminuya en gran medida. Otro aspecto que deberemos considerar es el tipo de coordenadas en que se vaya a trabajar. En determinadas circunstancias puede resultar interesante emplear coordenadas afines proyectivas, jacobianas o de López-Dahab. Los datos obtenidos en nuestra implementación está realizados sobre coordenadas afines, que en muchos casos pueden hacer que los resultados sean peores que los presentados en otros trabajos. Por ejemplo, el uso de otro tipo de


136

coordenadas diferentes a las afines puede conducir a que el diseño no incluya un divisor o inversor.

En [74], Hassan y Benaissa implementaron un criptoprocesador utilizando un FPGA de Xilinx de la familia Spartan 3 utilizando codiseño y tomando como base picoblaze. La implementación se realizó en GF(2163) con una frecuencia máxima de funcionamiento de 68.3 MHz y un tiempo de respuesta de 38 ms con una ocupación es de solo de 1127 slices dado el microcontrolador que utiliza. Comparado con el presente trabajo, aunque se llevase la frecuencia a los términos que utilizamos no alcanzaría resultados de tiempos de respuesta cercanos.

El diseño propuesto por Morales-Sandoval et al. en [75] utiliza un FPGA Virtex 4 en la que integra un PowerPC. Para trabajar en diferentes campos debe reconfigurarse, por lo que en función del que trabaje la ocupación sería una u otra. Está implementado utilizando coordenadas proyectivas y para trabajar en GF(2163) utiliza 3528 slices y tiene un tiempo de respuesta de 1,07 ms. Podemos comprobar que la ocupación es del mismo orden de magnitud y pese a que nuestra implementación utiliza coordenadas afines todavía obtenemos mejores tiempos de respuesta.

Loi y Seok-Bum [76] implementan un procesador escalable capaz de trabajar en los 5 campos propuestos por el NIST sin necesidad de ser rediseñado. Se implementa en una virtex 4 utilizando 4648 slices sin tener en cuenta los elementos de almacenamiento auxiliares y una frecuencia funcionando de 143 MHz proporciona un tiempo de respuesta de 1,97 ms para GF(2233) utilizando coordenadas de Lopez-Dahab. Salvo por esta circunstancia sería el más similar en cuanto a ocupación, pero aun así presenta peores tiempos de respuesta.

Aunque no sea directamente comparable, en [77] podemos encontrar la propuesta de un procesador dual capaz de trabajar en GF(p) y GF(2m) con tecnología CMOS de 90 nm. La implementación del mismo sobre un campo específico como es GF(2160) proporciona resultados de 0.29 ms operando a 204 MHz, que son mejores que los aquí presentados. Hemos de tener en cuenta que no realiza los productos utilizando un multiplicador de dígitos y que el campo utilizado es múltiplo del tamaño de palabra, por lo que para realizar una comparación deberíamos considerar en nuestra implementación el campo GF(2131). Si consideramos su ahorro de tiempo en

CAPÍTULO 5

137

los productos, en realidad la eficiencia no es tan considerable. En realidad, todos las implementaciones que realizan un producto en un solo ciclo de reloj van a presentar buenos resultados.

139

CAPÍTULO 6

CONCLUSIONESEl principal enfoque realizado en esta tesis ha sido la posibilidad de utilizar la criptografía de curvas elípticas en dispositivos de tamaño reducido aunque se empleen campos de trabajo grandes. Para ello nos hemos centrado en los campos de característica 2 y lo hemos hecho desde tres puntos de vista: el primero que, aunque se haya diseñado el microprocesador, es puramente software; un segundo que incluye al primero conjuntamente con una extensión hardware y el tercero que sería puramente hardware.

Inicialmente hemos diseñado un pequeño microprocesador de propósito general y hemos visto que se puede utilizar para realizar las principales operaciones que requeriría un protocolo de intercambio de claves, si bien los tiempos de respuesta que obtenemos para ello son bastante pobres. Para mejorarlos hemos introducido una pequeña cantidad extra de hardware al diseño inicial del microprocesador, que hace que mejoren en gran medida y que nos demostrarán que su diseño afecta directamente a los resultados que se obtienen. En concreto, el elemento multiplicador es clave debido que la multiplicación escalar es la operación básica.

CONCLUSIONES

140

Para mejorar este aspecto, hemos presentado un nuevo algoritmo y su arquitectura capaz de realizar la multiplicación de dos valores en módulo m. Se trata de un algoritmo que opera con dígitos en serie con la reducción intercalada. Inicialmente se ha realizado de forma que fuera capaz de operar en un campo múltiplo del tamaño de palabra elegido, para posteriormente mejorarlo haciéndolo capaz de operar en cualquier campo. Se ha implementado sobre un FPGA de pequeño tamaño (Xilinx Spartan SC3S500E) para los campos recomendados por el N.I.S.T. hasta un valor de 409 bits y con diferentes tamaños de palabra obteniéndose buenos tiempos de respuesta con bajo índice de ocupación de dispositivo.

Si bien un tamaño de palabra de 32 bits parece el más adecuado por la relación entre el tiempo de respuesta y la ocupación, en caso de necesidad se puede adoptar uno mayor, pues aunque pueda significar que tengamos que recurrir a un dispositivo de mayor tamaño, nos permitirá obtener excelentes tiempos de respuesta a costa de una ocupación que puede ser poco significativa en muchos de los chips disponibles hoy en día.

Posteriormente se ha realizado una propuesta de criptoprocesador que integre el multiplicador presentado conjuntamente con el resto de operadores necesarios para realizar las principales operaciones en un campo de trabajo de característica 2. Si bien hemos elegido coordenadas afines para realizar las diferentes pruebas de multiplicación escalar, las extrapolaciones de los resultados obtenidos son mejores que los presentados en otros trabajos con arquitecturas más específicas.

6.1 TRABAJOS FUTUROS La implementación de sistemas criptográficos presentan otros requisitos adicionales a los que aquí se han descrito, especialmente en aquellos entornos en los que los recursos son escasos.

Uno de los más importantes es el estudio de las necesidades energéticas en el uso de algoritmos de clave pública, sobre todo teniendo en cuenta la posibilidad de su utilización en dispositivos que funcionen de forma autónoma con su propia fuente de energía sin necesidad de mantenimiento o posibilidad de acceso externo.

Adicionalmente, si no se trata de un sistema tradicional al que no se pueda acceder fácilmente, deberemos también considerar su seguridad pues un

CAPÍTULO 6

141

atacante situado en el entorno podría tener la posibilidad de tratar de manipular el sistema. Por tanto, el almacenamiento de la clave privada con total seguridad en este tipo de dispositivos es todavía un reto importante a tener en cuenta sobre todo en los sistemas de dimensiones reducidas y de bajo coste.

143

BIBLIOGRAFÍA

[1] R. L. Rivest, "RSA Chips: Past/Present/Future," Advances inCryptology: Proceedings of EUROCRYPT'84, vol. 209, pp. 159-168,1984.

[2] M. Kochanski, "Developing an RSA chip," Advances in Cryptology:Proceedings of CRYPTO'85, vol. 218, pp. 350-357, 1985.

[3] F. Hoornaert, M. Decroos, J. Vandewalle, and R. Govaerts, "Fast RSAhardware: dream or reality," Advances in Cryptology: Proceedings ofEUROCRYPT'88, vol. 330, pp. 257-264, 1988.

[4] A. F. Tenca and Ç. K. Koç, "A scalable architecture for Montgomerymultiplication," Proceedings of 1st International Workshop onCryptographic Hardware and Embedded Systems (CHES), pp. 94-108,1999.

[5] A. F. Tenca, G. Todorov, and Ç. K. Koç, "High-radix design of a scalable modular multiplier," Proceedings of 3rd International Workshop onCryptographic Hardware and Embedded Systems (CHES), pp. 189-502, 2001.

[6] L. Gao, S. Shrivastava, and G. E. Sobelman, "Elliptic curve scalarmultiplier design using FPGAs," Proceedings of the FirstInternational Workshop on Cryptographic Hardware and EmbeddedSystems (CHES 1999), vol. 1717, pp. 257-305, 1999.

[7] J. L. Massey and J. K. Omura, "Computational Method and Apparatusfor Finite Field Arithmetic," USA Patent, 1986.

BIBLIOGRAFÍA

144

[8] G. Orlando and C. Paar, "A High Performance Reconfigurable EllipticCurve Processor for GF(2m)," presented at the Proceedings of theSecond International Workshop on Cryptographic Hardware andEmbedded Systems, 2000.

[9] L. Song and K. K. Parhi, "Low-Energy Digit-Serial/Parallel FiniteField Multipliers," Journal of VLSI Signal Processing Systems, vol. 19,pp. 149-166, 1998.

[10] T. Itoh and S. Tsujii, "A fast algorithm for computing multiplicativeinverses in GF(2m) using normal bases," Information andComputation, vol. 78, pp. 171-177, 1988.

[11] T. Kerins, E. Popovici, W. P. Marnane, and P. Fitzpatrick, "FullyParameterizable Elliptic Curve Cryptography Processor overGF(2m)," presented at the Proceedings of the ReconfigurableComputing Is Going Mainstream, 12th International Conference onField-Programmable Logic and Applications, 2002.

[12] M. Bednara, M. Daldrup, J. v. z. Gathen, J. Shokrollahi, and J. Teich,"Reconfigurable Implementation of Elliptic Curve CryptoAlgorithms," presented at the Proceedings of the 16th InternationalParallel and Distributed Processing Symposium, 2002.

[13] N. Gura, S. C. Shantz, H. Eberle, S. Gupta, V. Gupta, D. Finchelstein, etal., "An End-to-End Systems Approach to Elliptic CurveCryptography," 4th International Workshop on CryptographicHardware and Embedded Systems (CHES '02), pp. 349-365, 2003.

[14] J. Lutz and A. Hasan, "High Performance FPGA based Elliptic CurveCryptographic Co-Processor," presented at the InternationalConference on Information Technology: Coding and Computing(ITCC'04) Las Vegas, Nevada, USA, 2004.

[15] D. Aranha, A. Faz-Hernández, J. López, and F. Rodríguez-Henríquez,"Faster Implementation of Scalar Multiplication on Koblitz Curves,"in Progress in Cryptology – LATINCRYPT 2012. vol. 7533, A. Heviaand G. Neven, Eds., ed: Springer Berlin Heidelberg, 2012, pp. 177-193.

[16] N. A. Saqib, F. Rodriguez-Henriquez, and A. Diaz-Perez, "A parallelarchitecture for fast computation of elliptic curve scalarmultiplication over GF(2m)," in Proceedings. 18th InternationalParallel and Distributed Processing Symposium., 2004, p. 144.

[17] P. Qiong and H. Jianhua, "A Microcoded Elliptic Curve Processor forGF(2m) Using FPGA Technology," in International Conference onCommunications, Circuits and Systems Proceedings, 2006, pp. 2771-2775.

[18] Y.-B. Wang, X.-J. Dong, and Z.-G. Tian, "FPGA Based Design of EllipticCurve Cryptography Coprocessor," in Third International Conferenceon Natural Computation (ICNC '07), 2007, pp. 185-189.

BIBLIOGRAFÍA

145

[19] W. N. Chelton and M. Benaissa, "Fast Elliptic Curve Cryptography onFPGA," IEEE transactions on very large scale integration (VLSI)systems, vol. 16, pp. 198-205, 2008.

[20] S. Antao, R. Chaves, and L. Sousa, "Efficient FPGA elliptic curvecryptographic processor over GF(2m)," in International Conferenceon ICECE Technology (FPT '08). 2008, pp. 357-360.

[21] K. Ananyi, H. Alrimeih, and D. Rakhmatov, "Flexible HardwareProcessor for Elliptic Curve Cryptography Over NIST Prime Fields,"IEEE Transactions on Very Large Scale Integration (VLSI) Systems,,vol. 17, pp. 1099-1112, 2009.

[22] C. Chuanpeng and Q. Zhongping, "Improved elliptic curvecryptographic processor for general curves over GF(p)," in IEEE10th International Conference onSignal Processing (ICSP),, Beijing,2010, pp. 1849-1852.

[23] R. Azarderakhsh and A. Reyhani-Masoleh, "High-PerformanceImplementation of Point Multiplication on Koblitz Curves," Circuitsand Systems II: Express Briefs, IEEE Transactions on, vol. 60, pp. 41-45, 2013.

[24] H. Jun, D. Renfeng, Z. Lingyun, W. Shuai, Y. Zhiyi, and Z. Xiaoyang, "AHeterogeneous Multicore Crypto-Processor With Flexible Long-Word-Length Computation," Circuits and Systems I: Regular Papers,IEEE Transactions on, vol. 62, pp. 1372-1381, 2015.

[25] A. J. Menezes, P. C. v. Oorschot, and S. A. Vanstone, Handbook ofApplied Cryptography. Boca Raton, Florida: CRC Press. Taylor &Francis Group., 1997.

[26] R. Oppliger, Contemporary cryptography, 1st ed. Noorwood, MA:Artech House, Inc., 2005.

[27] J. Hoffstein, J. Pipher, and J. H. Silverman, An Introduction toMathematical Cryptography: Springer Science+Business Media, LLC,2008.

[28] R. L. Rivest, A. Shamir, and L. Adleman, "A method for obtainingdigital signatures and public-key cryptosystems," Communicationsof the ACM, vol. 21, pp. 120-126, February 1979.

[29] W. Diffie and M. E. Hellman, "Multiuser cryptographic techniques,"in Proceedings of AFIPS National Computer Conference, 1976, pp.109-112.

[30] T. ElGamal, "A public key cryptosystem and a signature schemebased on discrete logarithms," Advances in Cryptology - Proceedingsof CRYPTO’84, pp. 10-18, 1985.

[31] F. I. P. S. 193, "Secure Hash Standard," in Federal InformationProcessing Standards. Department of Commerce/N.I.S.T., ed, 1993.

[32] M. J. B. Robshaw and Y. L. Yin, "Elliptic Curve Cryptosystems," RSALaboratories1997.

BIBLIOGRAFÍA

146

[33] W. J. Caelli, E. P. Dawson, and S. A. Rea, "PKI, elliptic curve cryptography, and digital signatures," Computers & Security, vol. 18, pp. 47-66, 1999.

[34] O. Fournaris and A. Koufopavlou, "A New RSA Encryption Architecture and Hardware Implementation Based on Optimized Montgomery Multiplication," IEEE International Symposium on Circuits and Systems, vol. 5, pp. 4645-4648, 2005.

[35] R. K. Nichols, ICSA Guide to Cryptography, 1st ed.: McGraw-Hill Companies, 1999.

[36] L. C. Washington, Elliptic Curves. Number Theory and Cryptography: Chapman & Hall/CRE. Taylor & Francis Group., 2008.

[37] S. Vanstone. (2004, 20/07/2013). ECC Holds Key to Next-Gen Cryptography Design & Reuse. Available: http://www.design-reuse.com/articles/7409/ecc-holds-key-to-next-gen-cryptography.html

[38] A. J. Menezes, T. Okamoto, and S. Vanstone, "Reducing Elliptic Curve Logarithms to Logarithms in a Finite Field," IEEE Transactions on Information Theory, vol. 39, pp. 1639-1646, 1993.

[39] G. Frey and H. Ruck, "A Remark Concerning m-divisibility an the Discrete Logarithm in the Divisor Class Group of Curves," Mathematics of Computation, vol. 62, pp. 864-874, 1994.

[40] N. P. Smart, "The Discrete Logarithm Problem on Elliptic Curves of Trace One," HP Laboratories, Bristol, U.K. 97-128, 1997.

[41] T. Satoh and K. Araki, "Fermat Quotients an the Polynomial Time Discrete Log Algorithm for Anomalous Elliptic Curves," Commentarii Math. Univ. Sancti Pauli, vol. 47, pp. 81-92, 1998.

[42] A. J. Menezes and S. A. Vanstone, "Elliptic Curve Cryptosystems and Their Implementation," Journal of Cryptologhy, vol. 6, pp. 209-224, 1993.

[43] R. J. McEliece, Finite Fields for Computer Scientists and Engineers: Kluwer Academic Publishers, 1987.

[44] R. C. Mullin, I. M. Onyszchuk, S. A. Vanstone, and R. M. Wilson, "Optimal normal bases in GF(pn)," Discrete Applied Mathematics, vol. 22, pp. 149-161, 1989.

[45] F. I. P. S. 186-2, "Digital Signature Standard," in Federal Information Processing Standards Publication 186-2, National Institute for Standards and Technology, ed, 2000.

[46] IEEE, "IEEE Std 1363a-2004 (Amendment to IEEE Std 1363-2000)," in IEEE Standard Specifications for Public-Key Cryptography-Amendment 1: Additional Techniques, ed, 2004, pp. 1-159.

[47] J. López and R. Dahab, "High-Speed Software Multiplication in F(2m)," presented at the Proceedings of the First International Conference on Progress in Cryptology, 2000.

http://www.design-reuse.com/articles/7409/ecc-holds-key-to-next-gen-cryptography.html



BIBLIOGRAFÍA

147

[48] J. Guajardo, T. Kerins, S. S. Kumar, and P. Tuyls, "Finite FieldMultipliers for Ultra-Constrained Environments," presented at the2nd Benelux Workshop on Information and System Security,Luxembourg, Luxembourg, 2007.

[49] P. Kitsos, G. Theodoridis, and O. Koufopavlou, "An EfficientReconfigurable Multiplier Architecture for Galois field GF(2m),"Microelectronics Journal, vol. 34, pp. 975-980, 2003.

[50] R. Schroeppel, H. Orman, S. W. O'Malley, and O. Spatscheck, "Fast KeyExchange with Elliptic Curve Systems," presented at theProceedings of the 15th Annual International CryptologyConference on Advances in Cryptology, 1995.

[51] N. Koblitz, "Elliptic Curve Cryptosystems," Mathematics ofComputation, vol. 48, pp. 203-209, 1987.

[52] V. S. Miller, "Use of Elliptic Curves in Cryptography," Lecture Notes inComputer Sciences on Advances in Cryptology (CRYPTO '85), vol. 218,pp. 417-426, 1986.

[53] D. Hankerson, J. L. Hernandez, and A. Menezes, "SoftwareImplementation of Elliptic Curve Cryptography over Binary Fields,"presented at the Proceedings of the Second International Workshopon Cryptographic Hardware and Embedded Systems, 2000.

[54] W. Diffie and M. E. Hellman, "New directions in cryptography," IEEETransactions on Information Theory, vol. 22, pp. 644-654,Noviembre 1976.

[55]

[56]

J. López and R. Dahab, "Fast Multiplication on Elliptic Curves over GF(2m) without Precomputation," presented at the Proceedings of the First International Workshop on Cryptographic Hardware and Embedded Systems, 1999.

Atmel. (2014, 03/12/2014). TinyAVR (http://www.atmel.com/products/microcontrollers/avr/tinyavr.asp x).

[57] S. E. C. 2, "Standards for Efficient Cryptography Group:Recommended Elliptic Curve Domain Parameters," ed: CerticomCorp. Version 2.0, 2010.

[58] D. Hankerson, A. Menezes, and S. Vanstone, Guide to elliptic curvecryptography, 1st ed.: Springer-Verlag New York, Inc., 2004.

[59] P. G. Comba, "Exponentiation cryptosystems on the IBM PC " IBMSystems Journal, vol. 29, pp. 526-538, 1990.

[60] A. Karatsuba and Y. Ofman, "Multiplication of Many-Digital Numbersby Automatic Computers," Proceedings of the USSR Academy ofSciences, vol. 145, pp. 293-294, 1962.

[61] IEEE, "IEEE Standard Specifications for Public-Key CryptographyP1363-2000," ed, 2000.

http://www.atmel.com/products/microcontrollers/avr/tinyavr.aspx)

http://www.atmel.com/products/microcontrollers/avr/tinyavr.aspx)

BIBLIOGRAFÍA

148

[62] A. J. Menezes, M. Qu, and S. Vanstone, "Some new key agreementprotocols providing implicit authentications," 2nd Workshop onSelected Areas in Cryptography (SAC '95), pp. 22-32, 1995.

[63] K. Nyberg and R. Rueppel, "A new signature scheme based on theDSA giving message recovery," in First ACM Conference on Computerand Communications Security, 1993, pp. 58-61.

[64] C.-S. Yeh, I. S. Reed, and T. K. Truong, "Systolic Multipliers for FiniteFields GF(2m)," IEEE Transaction on Computers, vol. 33, pp. 357-360,1984.

[65] C. Paar and P. Soria-Rodriguez, "Fast arithmetic architectures forpublic-key algorithms over Galois fields GF((2n)m)," presented at the Proceedings of the 16th annual international conference on Theoryand application of cryptographic techniques, Konstanz, Germany,1997.

[66] L. Song and K. K. Parhi, "Efficient Finite Field Serial/ParallelMultiplication," presented at the Proceedings of the IEEEInternational Conference on Application-Specific Systems,Architectures, and Processors, 1996.

[67] G. N. Selimis, A. P. Fournaris, H. E. Michail, and O. Koufopavlou,"Improved throughput bit-serial multiplier for GF(2m) fields,"Integration. The VLSI Journal, vol. 42, pp. 217-226, 2009.

[68] G. Orlando and C. Paar, "A Super-Serial Galois Fields Multiplier forFPGAs and its Application to Public-Key Algorithms," in SeventhAnnual IEEE Symposium on Field-Programmable Custom ComputingMachines (FCCM '99), 1999, pp. 232-239.

[69] H. Wu, "Bit-Parallel Finite Field Multiplier and Squarer UsingPolynomial Basis," IEEE Trans. Comput., vol. 51, pp. 750-758, 2002.

[70] P. Gaudry, F. Hess, and N. Smart, "Constructive and destructive facetsof Weil descent on elliptic curves," Journal of Cryptology, vol. 15, pp.19-46, 2002.

[71] K. Kobayashi, N. Takagi, and K. Takagi, "An Algorithm for Inversionin GF(2m) Suitable for Implementation Using a Polynomial MultiplyInstruction on GF(2)," in 18th IEEE Symposium on ComputerArithmetic, 2007. ARITH '07., 2007, pp. 105-112.

[72]

[73]

N.I.S.T., "Digital Signature Standard (DSS)," in FIPS PUB 186-3, ed. Gaithersburg, MD: Departament of Comerce (U.S.A.), 2009.

M. Graphics. (02/09/2015). https://www.mentor.com/products/fv/modelsim/.

[74] M. N. Hassan and M. Benaissa, "A scalable hardware/software co-design for elliptic curve cryptography on PicoBlazemicrocontroller," in Circuits and Systems (ISCAS), Proceedings of2010 IEEE International Symposium on, 2010, pp. 2111-2114.

[75] M. Morales-Sandoval, C. Feregrino-Uribe, R. Cumplido, and I.Algredo-Badillo, "A reconfigurable GF(2m) elliptic curve

BIBLIOGRAFÍA

149

cryptographic coprocessor," in Programmable Logic (SPL), 2011 VII Southern Conference on, 2011, pp. 209-214.

[76] K. C. C. Loi and K. Seok-Bum, "High performance scalable ellipticcurve cryptosystem processor in GF(2m)," in Circuits and Systems(ISCAS), 2013 IEEE International Symposium on, 2013, pp. 2585-2588.

[77] L. Jen-Wei, C. Szu-Chi, C. Hsie-Chia, and L. Chen-Yi, "Efficient Power-Analysis-Resistant Dual-Field Elliptic Curve CryptographicProcessor Using Heterogeneous Dual-Processing-ElementArchitecture," Very Large Scale Integration (VLSI) Systems, IEEETransactions on, vol. 22, pp. 49-61, 2014.

Modelo de Criptoprocesador de Curvas Elípticas en … · 3.4 Extensión del repertorio de...

Documents

Transcript of Modelo de Criptoprocesador de Curvas Elípticas en … · 3.4 Extensión del repertorio de...