Nombre: Gómez Ávila Karla Paulina Materia: Análisis y Diseño de Algoritmos. Profesor: Dr. Francisco Rodríguez Henríquez. Tarea 2: Diseñar e implementar el Departamento de Ingeniería Eléctrica Sección de Computación algoritmo WNAF para expansión de coeficientes enteros. Fecha de entrega: viernes 17 de marzo de 2006 wNAF(window Non-Adyacent Form) Cuando calculamos nP con la multiplicación escalar de ECC, debemos primero transformar el número entero n en forma binaria. Después se multiplica el número binario con P, de esto resulta una curva elíptica típico de la multiplicación escalar. En esta multiplicación, las probabilidades de cada bit con valor de ‘0’ o ‘1’ es de 1/2. Y cuando la longitud de la entrada es n, entonces se necesita alrededor n tiempos de ECDBL [1] y n/2 tiempos de ECADD [2] (para cada bit ‘1’ se necesita un cálculo de ECDBL y uno de ECADD; y para cada bit ‘0’ se necesita solamente una vez ECDBL). Pero si la multiplicación escalar es calculada con la forma NAF en vez de la forma binaria, la velocidad de la multiplicación aumentará. NAF es un especial wNAF con un tamaño de ventana de 2. La entrada binaria es convertida de Derecha-a-Izquierda con las siguientes reglas: Cuando el bit actual es ‘0’, será guardado, y cuando el bit actual sea ‘1’, los dos bits siguientes se deben tratar como un bloque. Esto es, ‘01’ se mantiene como ‘01’ mientras que ‘11’ será substituido por ‘101’. En el segundo caso, el bloque genera un acarreo. Esto cambia el valor del siguiente bit, pero esto no es problema para analizar las características asintóticas (porque el bit siguiente puede ser ‘0’ o ‘1’, y cuando se obtiene un acarreo del bit precedente, se tiene la misma distribución de ‘0’ y ‘1’). Esto ahorra una time de ECADD con ‘0’ en lugar de ‘1’. Por esto cuando se calcula la multiplicación escalar de las curvas elípticas con la forma NAF en vez de la forma binaria, se necesita solamente alrededor n veces de ECDBL y n/3 veces de ECADD. wNAF tiene un tamaño de ventana w y realiza la conversión de la forma binaria de Derecha-a-Izquierda. Definición wNAF: Una secuencia de dígitos con signo es llamada wNAF si cumple las siguientes tres características: 1. El bit mas significativo no-cero es positivo. 2. Entre cada w dígitos consecutivos, al menos uno es un bit no-cero. 3. El valor absoluto de cada dígito no-cero es impar y menor que 2w-1. Para dos puntos P1 y P2 en la curva E (K), [1] P1 + P2 (P1 ≠ P2 ) es llamado ECADD y [2] P1 + P2 = 2 P1 (P1 = P2 ) Es llamado ECDBL. Existen diferentes algoritmos, que convierten la forma binaria en wNAF. El algoritmo propuesto para este caso de estudio es propuesto por Solinas. En este, "a mods b" se refiere a un modulo con signo, este es definido como a mod b, donde b b − ≤ a ≤ , y esto significa que el “mods” genera a veces un acarreo. Los valores 2 2 posibles de los bits no-cero usados para wNAF son: T = {±1, ±3, ±5,. . ., ± (2W−1 − 1)} Algoritmo propuesto: Generación de wNAF Entrada: tamaño de la ventana w, número entero d de n-bits Salida: tamaño de la ventana w, {σ n , σ n−1 ,K , σ 0 }w que es el wNAF de d i←0 while d ≥ 1 do if d is even then σ i ← 0; else σ i ← d mod s 2 w ; d ← d −σi; end if d ← d / 2; i ← i + 1; end while Return {σ n , σ n−1 ,K , σ 0 }w Desarrollo del algoritmo propuesto en VHDL: Este algoritmo fue desarrollado para un FPGA de la familia Spartan 2E. Se implementaron 7 módulos principales como se muestran a continuación: component mods port(entrada : in std_logic_vector(1 downto 0); enable : in std_logic; clock : in std_logic; salida : out std_logic_vector(3 downto 0)); end component; component comparador port(A: IN std_logic_VECTOR(162 downto 0); A_GE_B: OUT std_logic); end component; component resta port(A: IN std_logic_VECTOR(162 downto 0); B: IN std_logic_VECTOR(3 downto 0); S: OUT std_logic_VECTOR (164 downto 0)); end component; component mux2 port(a0,a1 : in std_logic_vector(1 downto 0); sel : in std_logic; cout : out std_logic_vector(1 downto 0)); end component; component mux163_reg port(MA: IN std_logic_VECTOR(162 downto 0); MB: IN std_logic_VECTOR(162 downto 0); S: IN std_logic_VECTOR(0 downto 0); Q: OUT std_logic_VECTOR(162 downto 0); CLK: IN std_logic); end component; component mux163 port(ain,bin : in std_logic_vector(162 downto 0); enable : in std_logic; c : out std_logic_vector(162 downto 0)); end component; component ciclo1 port(restain,escalarin : in std_logic_vector(162 downto 0); win : in std_logic_vector(1 downto 0); enable,sel : in std_logic; salida : out std_logic_vector(162 downto 0); wis : out std_logic_vector(1 downto 0)); end component; Los módulos “mods” y “mux2” fueron desarrollados para esta arquitectura, y el resto de los módulos se implementaron mediante un Core generator. Los códigos de cada uno de los módulos fueron anexados. El esquema sintetizado que presenta la herramienta como solución al problema es la siguiente: Fig. 1. Diagrama RTL de wNAF La cual tiene como entrada el número escalar que será expandido y como salida presenta la expansión de dicho escalar y el tamaño de la ventana que fue implementado. A continuación se presentan los diagramas de algunos módulos creados: Fig. 2 Esquema RTL expandido. Fig. 3 Esquema RTL del módulo “mods” Fig. 4 Esquema RTL del módulo que realiza los ciclos en el módulo “mods” Fig. 5 Esquema RTL que realiza las comparaciones bit a bit para la resta. Para poder implementar este algoritmo en la tarjeta propuesta se utilizó la memoria interna de la tarjeta, aquí se depositaron las entradas y las salidas del circuito, ya que al realizar la síntesis de la arquitectura presentaba un problema con el buffer de entrada y salida ya que este era superado por las entradas y salidas del circuito, como se presenta a continuación. Reporte de síntesis: Device utilization summary: --------------------------Selected Device: 2s200epq208-7 Number of Slices: Number of Slice Flip Flops: Number of 4 input LUTs: Number of bonded IOBs: Number of GCLKs: 525 out of 2352 22% 336 out of 4704 7% 828 out of 4704 17% 348 out of 146 238% (*) 2 out of 4 50% La memoria utilizada fue la siguiente: -- RAMB4_S16: Virtex/E, Spartan-II/IIE 256 x 16 Single-Port RAM -- Xilinx HDL Language Template version 8.1i RAMB4_S16_inst : RAMB4_S16 generic map ( INIT_00 => X"1110000011111111001100101001001111100010000011001010000011000110", INIT_01 => X"0110001010000101010100101100111001100110111110010111001011100010", INIT_02 => X"0110000001010000111110011101100000000000000000000000000000000000", INIT_03 => X"1001100001000000011010110010100101000011000100001011001010000101", INIT_04 => X"1001011010110001010000101010101011011010011010110100110000110101", INIT_05 => X"1001101011001100010101100000010100010000110100011011000000000000", INIT_06 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_07 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_08 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_09 => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0A => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0B => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0C => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0D => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0E => X"0000000000000000000000000000000000000000000000000000000000000000", INIT_0F => X"0000000000000000000000000000000000000000000000000000000000000000") port map ( DO => DO, -- 16-bit data output ADDR => ADDR, -- 8-bit address input CLK => CLK, -- Clock input DI => DI, -- 16-bit data input EN => EN, -- RAM enable input RST => RST, -- Synchronous reset input WE => WE -- RAM write enable input ); -- End of RAMB4_S16_inst instantiation Como se puede observar aquí fueron guardadas las entradas de los escalares evaluados, y aquí mismo son guardas las salidas por el proceso. Para comprobar los resultados se realizó el programa en Maple10. wnaf := proc( ) local i, wn, a, d; i := 162; wn := Array( 0 ..162 ); a := 8; while1 != d do if mod (d, 2 ) = 0 then wn [ i] := 0 else wn [ i] := mods ( d, a ); d := d K wn [i] end if; d := 1 /2 * d; i := i K 1 end do; returnwn end proc Los resultados obtenidos se presentan fueron: Fig. 6 Resultados wNAF con w =3;