servidor de la sección de computacióon - divisor modular...

Centro de Investigación y de Estudios Avanzados del IPN Departamento de Ingeniería Eléctrica

Sección de Computación

Divisor Modular

Materia: Aritmética Computacional

Profesor: Dr. Francisco Rodríguez Henríquez

Nombre: Jorge Ortiz García

Introducción

Las técnicas de cifrado en la criptología se basan en algoritmos, cuya implementación

demanda cada vez más poder de cómputo en sus dos áreas principales de interés, la criptografía y el

criptoanálisis. Aun cuando su implementación es más rápida y flexible, los algoritmos realizados en

software tienen un gran costo en tiempo de ejecución, de ahí que la idea es reducir este,

realizándolos en hardware. Sin embargo, debido a que su implementación en hardware VLSI es

inflexible, la opción es desarrollarlos en FPGAs, que son dispositivos intermedios entre el software

y el hardware.

El propósito de este documento es mostrar la implementación de un divisor modular, el cual

realiza la división de dos números contenidos en el campo binario GF(2m) en FPGAs, utilizando el

algoritmo binario de Euclides (Binary Euclidean Algorithm - BEA) para inversión en GF(2m) al

cual se le realiza una modificación para que funcione como un algoritmo de división en GF(2m).

La implementación de BEA es realizada en Maple, C++ (ANSI) y en VHDL. Las primeras

dos se realizaron para comprobar la efectividad del algoritmo, cada una con su propio enfoque de

desarrollo, además de proporcionar alternativas de prueba al momento de realizar la

implementación en VHDL.

Para facilitar la comprensión del documento es importante mencionar en primera instancia

algunos conceptos utilizados, para dar paso al desarrollo del de el proyecto y a las conclusiones.

Marco Teórico-Conceptual

Las siguientes definiciones son necesarias para una mejor compresión de la información

expuesta en este documento.

Campo

Una estructura < F , + , * > es un campo si F es un conjunto de elementos sobre los cuales se

han definido dos operaciones aritméticas las cuales normalmente son la suma(+) y

multiplicación(*), estas deben de cumplir las siguientes propiedades:

i) Cerradura: ∀ a,b ∈ F : a+b ∈ F y a*b ∈ F

ii) Asociativa: ∀ a,b,c ∈ F : (a+b)+c = a+(b+c) ∈ F y (a*b)*c=a*(b*c) ∈ F

iii) Conmutativa: ∀ a,b ∈ F : a+b = b+a ∈ F y a*b=b*a ∈ F

iv) Distributiva: ∀ a,b,c ∈ F : (a+b)*c = (a*c)+(b*c)

v) Elemento neutro: ∃ 0 ∈ F , ∀ a ∈ F : a+0=a y ∃ 1 ∈ F , ∀ a ∈ F : a*1=a

vi) Elemento Inverso: ∀ a ∈ F , ∃ b ∈ F : a+b=0 y ∀ a ∈ F-{0} , ∃ b ∈ F-{0} : a*b=1

Campo Finito

Un campo finito o campo de Galois es un campo que contiene un número finito de

elementos el cual es denotado como GF(q=pn), donde

• p es un primo y representa la característica del campo. • n es un entero y n>0 pues el campo es un espacio vectorial sobre p. • q el número de elementos que contiene el campo.

En la práctica los campos finitos más usado son los campos finitos primos GF(p) y los

campos finitos binarios GF(2m).

Campo primo GF(p)

Los campos primos son campos de orden p donde p es un número primo. Los enteros modulo

p consisten de todos los enteros {0,1,2,…,p-1}, con las operaciones de suma y multiplicación

realizadas con el modulo p. Para cualquier entero a la operación a mod p denota un único número

entero de residuo r tal que 0≤r≤p-1.

Campo binario GF(2m)

Los campos de orden 2

m son también llamados campos binarios o campos finitos de

característica dos. Una forma de representarlos es usando una base polinomial binaria de grado a lo

mas m-1, donde sus coeficientes encuentran en el campo F2={0,1}:

F2m={ am-1x

m-1 + am-2x

m-2 + …+ a2x

2 + a1x + a0 : ai ∈{0,1}}

Un polinomio binario irreducible f(x) = fmxm + fm-1x

m-1 + f2x

2 +f1x + f0 de grado m es elegido.

La irreducibilidad de f(x) significa que no puede ser factorizado como un producto de polinomios

binarios de grado menor a m.

La suma de elementos en este campo es la usual realizada en polinomios con aritmética de

coeficientes modulo 2 y la multiplicación de elementos es realizada con el modulo el polinomio

irreducible f(x).

Para cada polinomio a(x), a(x) mod f(x) denota un único polinomio de residuo r(x) de grado

menor a m obtenido a través de la división de a(x) por f(x), a esta operación se le llama reducción

modulo el polinomio irreducible f(x).

Division en GF(2m)

En los campos finitos solo están definidas las operaciones: suma y doblado (multiplicar por

2), pero a partir de estas con algoritmos podemos realizar la resta, la división, la exponenciación.

Para este caso veremos como realizar la división modular.

La división de la forma a/b como ya mencionamos, no esta definida en aritmética GF(2m),

pero si la expresamos como a*b-1

entonces la podemos realizar.

La división modular sobre GF(2m), la definimos de la siguiente manera

a/b = a*b-1 mod f(x)

donde a y b son polinomios de grado m-1 de la forma:

a(x) = am-1xm-1

+ am-2xm-2

+ …+ a2x2 + a1x + a0

b(x) = bm-1xm-1

+ bm-2xm-2

+ …+ a2x2 + b1x + b0

y b ≠ 0 , y el polinomio irreducible de grado m es

f(x) = fmxm + fm-1x

m-1 + f2x

2 + f1x + f0

Existe una relación entre el calculo del inverso de un numero y el calculo de la división, esto

es si a*b-1

es la división, entonces si a=1 tenemos 1*b-1 que es el inverso de un numero, por esta

razón algunos algoritmos para resolver inversos modulares en aritmética GF(2m) se les hacen

modificaciones para realizar divisiones modulares.

VLSI

Son circuitos integrados con una escala de integración muy grande, su siglas son acrónimo de

Very Large Scale Integration.

FPGA

Se trata de dispositivos electrónicos digitales programables de muy alta densidad. Sus siglas

son acrónimo de Field-Programmable Gate Array. Internamente tiene recursos básicos los cuales

son una serie de CLBs y IOBs.

CLB

Son dispositivos lógicos llamados CLB (Common Logic Block), organizados por filas y

columnas, entre los cuales hay un gran número de elementos de interconexión, líneas que pueden

unir unos CLB con otros y con otras partes de la FPGA. Los CLB contienen internamente otros

dispositivos llamados Slices.

Slices

Son dispositivos interconectados dentro de un CLB los cuales agrupan LUTs y Flip-Flops.

LUT

La lógica combinatoria esta basada en las Look-Up Tables (LUT) también llamadas FGs

(Function Generators).

IOB

Los IOB (Input/Output Buffer) son pequeños elementos en cada una de las patillas del chip

para definir la forma en que este trabajará (input, output). Estos contienen registros de memoria

VHDL Es un lenguaje de programación definido por el IEEE que se usa para diseñar circuitos

digitales. Sus siglas son un acrónimo que representa la combinación de VHSIC (Very High Speed

Integrated Circuit) y HDL (Hardware Description Language).

Desarrollo

Este proyecto es un divisor modular a*b-1

mod f(x) implementado en FPGAs el cual opera

sobre GF(2m), con m=233 lo que significa que contiene 2

233-1 elementos y trabaja con números de

233 bits.

Los Polinomios binarios a(x) y b(x) de grado m-1 = 232 son de la forma

a(x) = a232 x232

+ a231 x231

+ …+ a2 x2 + a1 x + a0

b(x) = b232 x232

+ b232 x231

+ …+ b2 x2 + b1 x + b0

con x=2 y el polinomio (para este caso es un trinomio) irreducible de grado m = 233 elegido,

el cual se utiliza para hacer la reducción y regresar los elementos al campo es

f(x) = x233

+ x74

+ 1 con x=2

el resultado de esta división es un polinomio de la forma

c(x) = c232 x232

+ c232 x231

+ …+ c2 x2 + c1 x + c0

Para realizar la división modular se utilizo el Algoritmo Binario de Euclides (BEA) para

inversos en GF(2m), modificando la asignación inicial de la variable g1 con el valor del dividendo a.

este algoritmo fue elegido debido a que se limita a entregar el resultado necesario, además de que

sus únicas operaciones sobre los datos son la suma polinomial que en hardware son realizadas por

xor y doblados que por ser aritmética binaria se convierten en corrimientos de bits.

Descripción del BEA modificado para la división modular

La división modular puede ser computada eficientemente con este algoritmo, el cual es una

variación del algoritmo clásico de Eucludes.

Este algoritmo tiene como variables a:

• a es el dividendo, a ≠ 0. • b es el divisor, b ≠ 0. • f(x) es el polinomio irreducible con x=2 para el caso de ser binario. • u, v, g1, g2 sobre las cuales opera el algoritmo.

INPUT : a, b 2 GF 02m1 , a, b s 0.OUTPUT : a$bK1 mod f (x ) .

1. u ) b, v ) f (x ) , g1 ) a, g2 ) 0;

2. While x divides u do :

2.1 u )u

x;

2.2 if x divides g1 then

g1 )g1

x;

else

g1 )(g1 C f (x ) )

x;

3. if u = 1 then return g1;

4. if deg (u ) ! deg (v ) then u 4 v, g1 4 g2;

5. u ) uC v, g1 ) g1 C g2;

6. Goto Step 2.

Los paso de ejecución del algoritmo enumerados como 1,2,3,4,5,6 son

• Paso 1: Se realiza la inicialización de variables locales con los valore de los números a y b, cabe hacer notar que la variable u recibe el valor de divisor y la variable g1 el valor del

dividendo.

• Paso 2: Se realiza un ciclo en el cual se hace reducción, en el cual se pide como condición de entrada que u sea un numero divisible entre 2 (sea numero par).

• Paso 2.1: Se divide u entre 2.

• Paso 2.2: Se verifica que g1 sea divisible entre 2 (sea un numero par), de ser correcto g1 es dividido por 2, en caso contrario se realiza la suma binaria de g1 y f(x) y después se divide

este resultado es por 2 y este ultimo resultado es asignado a g1.

• Paso 3: si u tiene como valor actual 1, el algoritmo termina y arroja el resultado de la división guardado en g1.

• Paso 4: Verifica que u sea menor a v, de ser así intercambia los valores de u y v, y los valores de g1 y g2.

• Paso 5: realiza la suma binaria de u y v, el resultado lo asigna a u después realiza la suma binaria de g1 y g2 y asigna el resultado en g1.

• Paso 6: Va al paso 2.

Binary Euclidean Algorithm (BEA) for inversion in GF(2m)

Implementación del BEA modificado para la división modular

La implementación del algoritmo binario de Euclides (BEA) para la división modular fue

realizada en tres herramientas diferentes, Maple, C++ (ANSI) y VHDL, donde esta ultima es de

interés por ser la herramienta de implementación en FPGAs y la cual constituye el desarrollo final

del proyecto. La razones por las cual se hicieron las dos primeras implementaciones son como

apoyo para el desarrollo y verificación del algoritmo en VHDL, cabe mencionar que cada

implementación tiene sus propias características debido al enfoque funcional de la herramienta, esto

nos ayuda a visualizar y comprender mas características y comportamientos del algoritmo.

Este algoritmo es secuencial, por lo que su implementación resulta mas sencilla también de

manera secuencial.

Algoritmo en Maple

Maple es una herramienta indispensable para el calculo de valores de operaciones y

algoritmos referentes a GF(2m).

La implementación de BEA en Maple trajo como consecuencia la realización de

conversiones de números enteros a polinomios para poder operar con estos últimos (estrictamente

en el caso de las sumas y las divisiones), el código es el siguiente:

divisor_poly:= proc(a,b)

local u,v, g1,g2,f,aux, u_polinomio, v_polinomio, g1_polinomio, g2_polinomio,

f_polinomio, dos_polinomio, GField;

P:=x^233+x^74+1;

N:=233;

GField:=GF(2,N,P);

f:=13803492693581127574869511724554050904902217944359662576256527028453377;

#STEP 1 ------------------------------------------------------------------

u:=a, v:=f, g1:=b, g2:=0;

f_polinomio:=GField[input](f);

dos_polinomio:=GField[input](2);

u_polinomio:=GField[input](u);

v_polinomio:=GField[input](v);

g1_polinomio:=GField[input](g1);


while true do

#STEP 2 -----------------------------------------------------------

while (u mod 2)=0 do

#STEP 2.1 -----------------------------------------------------------

#u:=u/2;

u_polinomio:=GField[`/`](u_polinomio,dos_polinomio);

u:=GField[output](u_polinomio);

#STEP 2.2 -----------------------------------------------------------

if (g1 mod 2)=0 then

#g1:=g1/2;

g1_polinomio:=GField[`/`](g1_polinomio,dos_polinomio);

g1:=GField[output](g1_polinomio);

else

#g1:=(g1+f)/2;

g1_polinomio:=GField[`+`](g1_polinomio,f_polinomio);

g1_polinomio:=GField[`/`](g1_polinomio,dos_polinomio);


end if;

end do;

#STEP 3 -----------------------------------------------------------

if u = 1 then

#return g1;

return g1;

end if;

#STEP 4 -----------------------------------------------------------

if (u < v) then

aux:=u;

u:=v;

v:=aux;

aux:=g1;

g1:=g2;

g2:=aux;

u_polinomio:=GField[input](u);

v_polinomio:=GField[input](v);



end if;

#STEP 5 -----------------------------------------------------------

#u:= u + v;

u_polinomio:=GField[`+`](u_polinomio,v_polinomio);

u:=GField[output](u_polinomio);

#g1:=g1 + g2;

g1_polinomio:=GField[`+`](g1_polinomio,g2_polinomio);


end do;

end proc;

Este código implementado es completamente eficiente, cabe resaltar que por el uso de la

librería de campos finitos GF, el calculo de la división modular puede realizarse para operandos

mas grandes o iguales que el grado del polinomio irreducible y retornar valores correctos, esto

sucede porque en las divisiones por 2 (paso 2.1 y 2.2) son resueltas de manera polinomial.

Algoritmo en C

Este desarrollo fue hecho con el objeto de manejar una implementación intermedia entre

Maple y VHDL, por esta razón utiliza arreglos de enteros que simulan los vectores de bits con el

objeto de asemejarse más al manejo en hardware y de esta manera realizar la implementación en

VHDL de una manera similar por lo menos en el manejo de los vectores.

En este programa se realizaron funciones de llenado de vectores de bits a través de un

número o de posiciones de los bits encendidos.

Se realizo una función de copia de arreglos y otra función de suma de vectores (xor) así como

funciones que imprimen el vector en base binaria y en hexadecimal.

Las evaluaciones de “=” y “

copyIntArray(g1,b,BIT_MAX); //g1

Algoritmo en VHDL

La implementación del divisor modular en VHDL es el objetivo principal del proyecto, ya

que al ser una herramienta que ofrece menor tiempo de ejecución que el Software y mayor

flexibilidad que el Hardware VLSI, es ideal para realizar desarrollos en Hardware con la facilidad

del Software.

Las características de la tarjeta FPGA en la que se realizara esta implementación son las

siguientes:

Familia: Vertex 2

Dispositivo: XC2V8000

Paquete: FF1152

Velocidad: -4

Este circuito maneja 4 señales de entrada y 1 de salida, dos de las señales de entrada son

vectores de números a y b, una de las otras es de un reset el cual dispara la ejecución del divisor y la

otra es la entrada del reloj la cual sincroniza la maquina de estados.

El desarrollo de BEA para la división en GF(2m) es de manera secuencial, esto es porque se

utilizaron Maquinas de Estado Finito (Finite State Machines- FSM), las cuales coinciden con los

pasos del algoritmo, los estados son: zero, one, two, two_one, two_two, three, four, five, end_fsm.

• Estado zero: Se limpian (inicializan a 0’s) las variables u,v,g1,g2 y cambia a one el estado siguiente.

• Estado one: Se realiza la inicialización de las señales locales con los valores de los vectores a y b, cambia el estado siguiente a two.

• Estado two: Se realiza un estado para verificar que el vector de bits u es par, de serlo el estado siguiente es two_one en otro caso el estado siguiente es three.

• Estado two_one: Se realiza un corrimiento a la derecha de del vector u (dividir entre 2), el siguiente estado es marcado como two_two.

• Estado two_two: Se verifica que g1 sea un numero par, de ser correcto se le hace un corrimiento a la derecha a g1, en caso contrario se realiza un xor sobre g1 y f(x) y después a

este resultado se le hace un corrimiento a la derecha es asignado de nuevo a g1.

• Estado three: Si el vector u tiene como valor actual 1, termina y arroja el resultado de la división modular guardado en c y pasa al estado end_fsm, en otro caso el estado siguiente es

marcado como four.

• Estado four: Verifica que el vector u sea menor que el vector v, de ser así intercambia los valores de los vectores u y v, y los valores de g1 y g2 y marca el siguiente estado como five.

• Estado five: realiza la suma xor de los vectores u y v, el resultado lo asigna a u después realiza el mismo procedimiento para g1 y g2 y asigna el resultado en g1.Pasa al estado two.

• Estado end_fms: Este estado no hace nada mas que quedarse ahí mismo.

• La implementación de las sumas para GF(2m), son multiplicaciones de xors y los corrimientos son recableado de los datos.

El siguiente código pertenece al modulo VHDL que realiza la división modular de manera

secuencial.

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

use IEEE.STD_LOGIC_ARITH.ALL;

use IEEE.STD_LOGIC_UNSIGNED.ALL;

entity divisor_modular is

Port ( CLK : in STD_LOGIC;

RESET : in STD_LOGIC;

A : in STD_LOGIC_VECTOR (232 downto 0);

B : in STD_LOGIC_VECTOR (232 downto 0);

C : out STD_LOGIC_VECTOR (232 downto 0));

end divisor_modular;

architecture Behavioral of divisor_modular is

--STATES OF FSM-------------------------------------------------------------------

type STATE is (ZERO, ONE, TWO, TWO_ONE, TWO_TWO, THREE, FOUR, FIVE,

END_FSM);

--SIGNALS OF FSM------------------------------------------------------------------

signal CURRENT_STATE, NEXT_STATE : STATE;

--ALGORITHM SIGNALS ---------------------------------------------------------------

signal U,V,G1,G2 : STD_LOGIC_VECTOR (233 downto 0);

-- REDUCTION POLYNOMIAL ----------------------------------------------------------

signal F : STD_LOGIC_VECTOR (233 downto 0):=( 233=>'1' , 74=>'1' , 0=>'1' , others=>'0' );

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

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

begin

-- LOWER SECTION (SEQUENTIAL)-----------------------------------------------------------------

process (RESET,CLK)

begin

if (RESET='1') then

CURRENT_STATE

else

AUX := G1 xor F;

G1(232 downto 0)

El reporte de la síntesis e implementación de diseño es :

Ejecución de prueba

Para este ejemplo utilizamos los siguientes vectores de 233 bits los cuales se probaran en las

tres implementaciones.

Los vectores de entrada son:

a = 1BA4EE4092B18F868638C16A625474BA8C43039CD1A8C006D5FFE2D7810;

b = 1BA4EE4092B18F868638C16A625474BA8C43039CD1A8C006D5FFE2D7810;

el vector resultante debe de ser:

c = 127D2FFD76EB439C4AAD075465E2BCCC4619C9E043914875BD677115A40;

El resultado en Maple es correcto

El resultado en c++ (ANSI) es correcto

El resultado en VHDL es correcto.

Conclusiones

Existen varias metodologías, procedimientos y algoritmos para realizar operaciones

modulares en aritmética GP(2m), sus diferencias radican en la rapidez, complejidad, eficiencia y el

enfoque con el cual se hayan planteado.

Algunas implementaciones son muy difíciles de realizar debido a las características del

método o algoritmo, mientras que otras son mucho mas directas, este ultimo es el caso del divisor

modular, el cual si el desarrollador no tiene mucho conocimiento podría pensar que la forma de

realizarlo es compleja, pero lo cierto es que puede ser resuelto modificando algoritmos de inversión

como se hizo en este proyecto.

La utilización de Maquinas de Estado Finito (diseño secuencial) proporcionan una gran

flexibilidad al momento de realizar algoritmos en VHDL. Pero no hay que olvidar que estos tienen

un costo mucho mayor de tiempo que los diseños paralelos.

Por estas diferentes razones, es importante pensar un buen diseño antes de realizar una

implementación en alguna herramienta.

Referencias

• Dr. Francisco Rodríguez Enríquez.: http://delta.cs.cinvestav.mx/~francisco/arith/arith06.html (apuntes).

• Kenny Fong, Darrel Hankerson, Julio López, and Alfred Menezes, Field Inversion and Point Halving Revisited (publicación).

• Andrew Rushton. Wiley.: VHDL for Logic Síntesis 2nd Edition (libro).

servidor de la sección de computacióon - divisor modular...

Documents