Centro de Investigación y Estudios Avanzados del IPN

Departamento: Ingeniería Eléctrica

Sección: Computación Asignatura: Aritmética Computacional Profesores: Dr. Francisco Rodríguez Henríquez Dr. Arturo Díaz Pérez

INVERSO MULTIPLICATIVO MODULAR EN GF(P) Y GF(2M)

– PROYECTO FINAL –

Alumnas: Abigail Martínez Rivas Claudia Magdalena Ramírez Trejo

3 de Mayo del 2004

INTRODUCCIÓN La aritmética modular es la base de muchas operaciones en aplicaciones criptográficas. Particularmente, la inversión modular es usada en aplicaciones tales como la generación de las llaves publica y privada en el sistema RSA, en el algoritmo de intercambio de llave de Diffie-Hellman y más recientemente en Criptografía de Curvas Elípticas (ECC). La inversión modular también puede ser usada para acelerar la exponenciación modular en conjunto con las cadenas de adición–substracción, entre otras aplicaciones. Los cálculos del inverso para criptografía se encuentran normalmente definidos sobre el campo GF(p) o bien GF(2m). Si para una aplicación se cuenta con un dispositivo de hardware que compute en GF(2m) y fuese requerido además realizar cálculos en GF(p), sería necesario agregar un dispositivo totalmente diferente. Tener dos diseños de hardware (uno para GF(p) y otro para GF(2m)) resulta ineficiente cuando sólo se utiliza uno a la vez. Esta situación motiva a implementar una arquitectura de hardware unificada, capaz de calcular el inverso para ambos campos.

DESARROLLO

1. Algoritmo Para diseñar una arquitectura unificada es necesario que los algoritmos para hallar el inverso modular en GF(p) y GF(2m) sean muy similares, de esta manera se consume la menor cantidad de hardware extra. Entre los algoritmos existentes, el que presenta mayor similitud para ambos campos es el algoritmo de Montgomery, del cual puede usarse una modificación para obtener el inverso en el campo y dominio adecuados. El inverso modular de Montgomery de un número entero a está dado por:

X = MonInv(a) = a– 1 2m (mod p) donde m es la longitud en bits de p. El algoritmo para computar el inverso de Montgomery de un número entero a consta de dos fases. La fase I es el Almost Montgomery Inverse cuya salida es r, tal que:

r = AlmMonInv(a, p) = a– 1 2k (mod p) donde m ≤ k ≤ 2m.

Fase I: Almost Montgomery Inverse

AlmMonInv (a, p) Entrada: a ∈ [1, p – 1] y p Salida: r y k, donde r = a– 1 2k (mod p) y m ≤ k ≤ 2m u := p, v := a, r := 0, s := 1, k := 0 while ( v > 0) if u is even then u := u/2, s := 2s else if v is even then v := v/2, r := 2r else if u > v then u := (u – v)/2, r := r + s, s := 2s else v := (v – u)/2, s := s + r, r := 2r k := k + 1 if r ≥ p then r := r – p r := p – r return r, k

Figura 1. Procedimiento “Almost Montgomery Inverse” El resultado de la fase I se usa como entrada para la fase II donde es obtenido el inverso de Montgomery. Si la entrada a AlmMonInv se encuentra en el dominio de Montgomery, es decir a2m, entonces la salida de la fase I será

r = AlmMonInv (a2m, p) = a–1 2 – m 2k = a–1 2(k – m) y en la segunda fase será necesario dividir a r por 2, k – 2m veces para obtener a–1 2 m. Como el objetivo de este proyecto es hallar el inverso modular en GF(p) ó GF(2m) y no en el dominio de Montgomery, la entrada a AlmMonInv será únicamente a, y en la fase II sólo serán necesarias k divisiones por 2.

Fase II: Real Modular Inverse

ModInv (r, p, k) Entrada: r, p y k Salida: x, donde x = a – 1 (mod p) for i = 1 to k do if r is even then r := r/2 else r := (r + p)/2 x := r return x

Figura 2. Procedimiento “Real Modular Inverse”

El algoritmo de Montgomery tal como se acaba de mostrar, calcula en inverso modular en GF(p). Extender el algoritmo para GF(2m) significa sólo remover el acarreo de propagación en la suma, y hacer las restas igual que las sumas.

2. Diseño en Hardware • Laobind

clo

PUERTOS PUERTOS

s entradas al circuito son los números a y p de n bits de longitud, el campo en el que se tendrá el inverso modular y una señal de carga. La salida es a – 1mod p más una señal que ica que el resultado está listo. La siguiente figura ilustra lo descrito.

READYLOAD

nMODINV

clock

FIELD

P

An

n

P(0)

Fase II nMODINV

ck

A

P

FIELD Fase I

n

LOAD

R

K

ACT2

m

CLEAR

nn

0 GF( 2m ) FIELD 1 GF( p )

LOAD 0 Cargar los valores a los registros

• PUERTOS DIAGRAMA DE FLUJO

Load

B

0

0

UV2UV1UV0 = X10

1

1UV2UV1UV0 = 100

1 u := m_u v := m_v s := m_s r := m_r

UV := vSR := r

UV := u SR := s

1

0 u0 = 0

ShiftR(UV, 1) ShiftL(SR, 1) k := k + 1

ShiftR(UV, 2) ShiftL(SR, 2) k := k + 2

0

1

1 ShiftR(UV, 3) ShiftL(SR, 3) k := k + 3

UV2UV1UV0 = 000

A 0

1

0 p0 ≠ 0

0

v ≠ 0

u := p v := a s := 1 r := 0 k := 0 Ready1 := 0

FFAASSEE II Entrada: a y p Salida: r = a– 1 2k (mod p) y k

proceso.

En m_u, m_v, m_s y m_r se almacenan los valores que deben tomar u, v, s y r durante el

B

v := sh_sub;r := ShiftL(r, 1)s := addSR

u := sh_sub;s := ShiftL(s, 1) r := addSR

1

0sign = 0

subUV := Substract(u, v, sign)addSR := Add(s, r) sh_sub := ShiftR(subUV, 1) k = k + 1

Ready1 := 1

result := sub2PR

result := subPR

1

0signPR = 0

subPR := Substract(p, r, signPR)sub2PR := Substract(p, subPR) A

En esta fase se cargan los valores de a y p a los registros u y v. La operación mas relevante en esta fase consiste en dividir los valores en los registros u y v por 2 en tanto sea posible. Para realizar este proceso de manera más rápida, se verifica si los bits menos significativos de u o v son 000, 100 o X10 para determinar si tales valores pueden ser divididos por 8, 4 o 2 respectivamente. Cuando el proceso finaliza, se carga en Ready1 el valor de 1, lo cual da inicio a la fase II.

FFAASSEE IIII

Ready2 := 1

rp := Add(invMod, p)invMod := ShiftR(rp, 1)

invMod := ShiftR(invMod, 1)

1

0 invMod0 = 0

1

0 Ready1 = 1

cont := cont + 1

cont := 0invMod := r Ready2 := 0

1

0 cont ≠ k

Entrada: r, p y k Salida: modInv = a– 1 (mod p) En esta fase se carga el valor de r al registro invMod, al cual se le aplican corrimientos hacia la derecha k veces. En cada ciclo se verifica que el bit menos significativo de invMod sea 0 (que invMod sea par), en caso afirmativo se aplica en corrimiento, de lo contrario, a invMod se le suma p y se aplica en corrimiento. Cuando el proceso se ha terminado, se carga a la señal Ready2 el valor de 1. La señal que indica que el resultado final está listo se activa con Ready1 and Ready2.

3. Implementación en VHDL • PUERTOS

En la siguiente tabla se indican los diferentes valores que pueden ser cargados en los en cada registro durante el proceso.

Registro Operación Expresión de control

u u ← p u ← m_u

Load’ Load

m_u m_u ← u m_u ← sh_uv m_u ← ShiftR(subUV, 1)

MU1’ & MU2’ MU1’ & MU2 MU1 & MU2’

v v ← a v ← m_v

Load’ Load

m_v m_v ← v m_v ← sh_uv m_v ← ShiftR(subUV, 1)

MV1’ & MV2’ MV1’ & MV2 MV1 & MV2’

s s ← 1 s ← m_s

Load’ Load

m_s m_s ← s m_s ← sh_sr m_s ← addSR

MS1’ & MS2’ MS1’ & MS2 MS1 & MS2’

r r ← 0 r ← m_r

Load’ Load

m_r m_r ← r m_r ← sh_sr m_r ← addSR

MR1’ & MR2’ MR1’ & MR2 MR1 & MR2’

UV UV ← u UV ← v

u(0)’ u(0)

sh_uv sh_uv ← ShiftR(UV, 1) sh_uv ← ShiftR(UV, 2) sh_uv ← ShiftR(UV, 3)

A’ & B’ A’ & B A & B’

SR SR ← s SR ← r

u(0)’ u(0)

sh_sr sh_sr ← ShiftR(SR, 1) sh_sr ← ShiftR(SR, 2) sh_sr ← ShiftR(SR, 3)

A’ & B’ A’ & B A & B’

k k ← 0 k ← Add(k, kuv)

Clr clk_act

Result Result ← Substract(p, r) Result ← Substract(2p, r)

subPRborrow subPRborrow’

REGISTROS

• PUERTOS EXPRESIONES DE CONTROL

Expresiones de Control Evaluación

MU1 u(0) and v(0) and (not subUVborrow)

MU2 not u(0)

MV1 u(0) and v(0) and subUVborrow

MV2 u(0) and not v(0)

MS1 u(0) and v(0)

MS2 not u(0) or (v(0) and subUVborrow)

MR1 MS1

MR2 u(0) and (not (v(0) and subUVborrow))

A not UV(2) and (not UV(1))

B UV(2) and not UV(1)

kuv sel_kuv1&sel_kuv2

sel_kuv1 not UV(1) and not UV(0)

sel_kuv2 not UV(2) or UV(1) or UV(0)

clk_act Clk and (v ≠ 0)

• BLOQUES BLOQUES

FFAASSEE II

clk_act

clk act

clk_act

clk_act

clk_actZ

p

FIELD

CLR

LOAD

FIELD

p

a

UV

SR sh_sr

sh_uv

subUV ShiftR

A B

kuv

K

CLR

K Add

RES

rr

RES1 RES2

Mux

Addprr

Add

FIELD

Mux s

ShiftL1

ShiftL3

A B

Mux

ShiftR3

ShiftR1

READY clk act

CLK v 0

≠

s r FIELD

Add

CLK

READY RES

u(0)

ShiftL2 LOAD

LOAD

MR1 MR2

MS1 MS2

MV1 MV2

MU1 MU2

u(0)

rr

rs

0 rs

1 rr

Mux

Mux

u v FIELD

LOAD

LOAD

a rv

p ru ru

rv Mux

Mux

| Substract |

ShiftR2Mux

Mux

v Mux

r Mux

s Mux

u Mux

FFAASSEE IIII

&

high-1 to 0

carry

FIEL

Add P

&0

RESULT

rr high-1 to 0

LOAD

READYK

1

≠

CLR

Counter

≠

MODINV

r

rr‘low

ACT2

CLK

CLR

FIELD

K

P

Mux 2 x 1

r Mux 2 x 1

Adder Los acarreos dentro del sumador están conectados a una compuerta and con el campo, de modo que si el campo es GF(2m) ( FIELD = 0 ) los acarreos son despreciados.

FIELD

nADD

CARRY

B

An

n Substract Esta unidad devuelve el valor absoluto de la resta de sus entradas y la bandera borrow que indica si al realizar la resta el resultado fue positivo (0) o negativo (1).

nBORROW

FIELD

nSUBB

An

n

4. Reporte de Desempeño =======================================================

HDL Synthesis Report ======================================================= Macro Statistics # Registers: 112 1-bit register: 112 # Multiplexers: 261 2-to-1 multiplexer: 165 1-bit 4-to-1 multiplexer: 96 # Comparators: 6 16-bit comparator not equal: 6 # Xors: 207 1-bit xor2: 192 16-bit xor2: 15 =======================================================

* Low Level Synthesis * ======================================================= Optimizing unit <modinv> ... Optimizing unit <AdderP4> ... Optimizing unit <MonInvII> ... Optimizing unit <Complement2> ... Optimizing unit <AlmMonInv> ... Loading device for application Xst from file '2s300e.nph' in environment C:/Xilinx. Mapping all equations... Building and optimizing final netlist ... Found area constraint ratio of 100 (+ 5) on block modinv, actual ratio is 17. FlipFlop ALM_FDU0_dout has been replicated 6 time(s) FlipFlop ALM_FDV0_dout has been replicated 1 time(s)

======================================================= * Final Report *

======================================================= Device utilization summary: -------------------------------------------------------------------------------------------------------------- Selected Device : 2s300eft256-6 Number of Slices: 512 out of 3072 16% Number of Slice Flip Flops: 119 out of 6144 1% Number of 4 input LUTs: 953 out of 6144 15% Number of bonded IOBs: 52 out of 182 28% =======================================================

TIMING REPORT ======================================================= Timing Summary: -------------------------------------------------------------------------------------------------------------- Speed Grade: -6 Minimum period: 36.646ns (Maximum Frequency: 27.288MHz) Minimum input arrival time before clock: 72.073ns Maximum output required time after clock: 12.641ns Maximum combinational path delay: No path found

5. Referencias

•

•

Fast Modular Inversion in Montgomery Domain on Reconfigurable Logic Alan Daly, Liam Marnane, Emanuel Popovici Scalable and Unified Hardware to Compute Montgomery Inverse in GF(p) and GF(2m) Adnan Abdul–Aziz Gutub, Alexandre F. Tenca, Erkay Savaş, Çetin K. Koç