Implementación de un diseño con una buena relación de ...

Implementación de un diseño con una buena relación de potencia y desempeño del

algoritmo AES-128

Ing. John Alexander Contreras Medina

Director:

Ing. Jorge García Pabón

Ingeniería Electrónica Facultad de Ingeniería

Pontificia Universidad Javeriana Bogotá

Colombia

PONTIFICIA UNIVERSIDAD JAVERIANA FACULTAD DE INGENIERÍA CARRERA DE INGENIERÍA ELECTRÓNICA

RECTOR MAGNIFICO: PADRE JOAQUIN EMILIO SANCHEZ GARCIA S.J

DECANO ACADEMICO: ING. JORGE SANCHEZ

DECANO DEL MEDIO UNIVERSITARIO: PADRE SERGIO BERNAL

RESTREPOS.J

DIRECTOR DE LA MAESTRIA ING. CESAR LEONARDO NIÑO

DIRECTORES DE PROYECTO: ING. JORGE GARCIA PABON

NOTA DE ADVERTENCIA

La Universidad no se hace responsable de los conceptos emitidos por sus

alumnos en sus proyectos de grado.

Solo velará porque no se publique nada contrario al dogma y la moral católica y

porque los trabajos no contengan ataques o polémicas puramente personales.

Antes bien, que se vea en ellos el anhelo de buscar la verdad y la justicia.

Artículo 23 de la Resolución No. 13, del 6 de julio de 1946, por la cual se

reglamenta lo concerniente a Tesis y Exámenes de Grado en la Pontificia

Universidad Javeriana

AGRADECIMIENTOS

Primero a Dios por siempre guiarme en mis decisiones y porque sabe del gran esfuerzo

que realice para llegar a este gran momento.

Agradezco a mi familia quien me apoyo con cada día para poder realizar mis estudios y

formarme como persona útil a la sociedad, a mi tutor el Ing. Jorge García Pabón por toda

su colaboración y enseñanzas durante todo el proceso de realización de la tesis

1

Tabla de contenido

Índice de figuras .................................................................................................................................. 4

Índice de Tablas .................................................................................................................................. 7

1. INTRODUCCIÓN ...................................................................................................................... 8

2. MARCO TEÓRICO .................................................................................................................. 10

2.1 Criptografía ....................................................................................................................... 10

2.2. Matemática preliminar.................................................................................................... 12

2.2.1. Campos finitos ........................................................................................................ 12

2.2.2. Representación de polinomio ............................................................................... 13

2.2.3. Representación Campo GF ( ) .......................................................................... 13

2.2.4. Suma en el Campo GF ( ) .................................................................................. 13

2.2.5. Multiplicación en el Campo GF ( ) .................................................................... 14

2.2.6. Multiplicación por x ................................................................................................. 14

2.3. Algoritmo de encripción Rijndael .................................................................................. 16

2.3.1. Cifrado Rijndael ...................................................................................................... 18

2.3.1.1. Función AddRoundKey .................................................................................. 19

2.3.1.2. Función ByteSub ............................................................................................ 19

2.3.1.3. Función ShiftRow ............................................................................................ 21

2.3.1.4. Función InvShiftRow ...................................................................................... 22

2.3.1.5. Función MixColumns ...................................................................................... 22

2.3.1.6. Función InvMixColumns ................................................................................ 23

2.3.1.7. Función de expansión de la clave ................................................................ 24

2.4. Potencia ........................................................................................................................... 27

2.4.1. Potencia estática .................................................................................................... 27

2.4.2. Potencia dinámica .................................................................................................. 28

2.4.2.1. Corriente de corto circuito ............................................................................. 29

2.4.2.2. Corriente de Leakage .................................................................................... 29

2.5. Pipeline ............................................................................................................................. 29

2.6. Auto Pipeline ................................................................................................................... 30

2.7. Testbench ........................................................................................................................ 31

3. OBJETIVOS ............................................................................................................................. 33

3.1 Objetivo general ................................................................................................................ 33

2

3.2 Objetivos específicos......................................................................................................... 33

4. ESPECIFICACIONES .............................................................................................................. 34

5. DESARROLLO ........................................................................................................................ 38

5.1. Implementación del algoritmo AES-128 en C. ........................................................... 38

5.2. Implementación del algoritmo de encripción AES-128 en RTL ............................... 43

5.2.1. Módulo AddroundKey ............................................................................................ 43

5.2.2. Módulo ByteSub...................................................................................................... 44

5.2.3. Módulo ShiftRows ................................................................................................... 45

5.2.4. Módulo MixColumns ............................................................................................... 45

5.2.4.1. Sub-Módulo Comb1 ....................................................................................... 47

5.2.4.2. Sub-Módulo Comb2 ....................................................................................... 49

5.2.4.3. Sub-Módulo Comb3 ....................................................................................... 50

5.2.4.4. Sub-Módulo Comb4 ....................................................................................... 51

5.2.5. Módulo KeyExpansion ........................................................................................... 51

5.2.5.1. Sub-Módulo M4 ............................................................................................... 52

5.2.5.2. Sub-Módulo NM4 ............................................................................................ 53

5.3. Implementación del algoritmo de des-encripción AES-128 en RTL ....................... 54

5.3.1. Módulo Inv_AddroundKey ..................................................................................... 55

5.3.2. Módulo Inv_ByteSub .............................................................................................. 56

5.3.3. Módulo Inv_ShiftRows ........................................................................................... 56

5.3.4. Módulo Inv_Mixcolumns ........................................................................................ 56

5.3.4.1. Sub-Módulo Inv_Comb1 ................................................................................ 56




5.4. Testbench ........................................................................................................................ 58

5.4.1. Verificación .............................................................................................................. 62

5.5. Líneas de Pipe (optimización) ...................................................................................... 67

5.6. Síntesis ............................................................................................................................. 68

5.7. Plan de pruebas .............................................................................................................. 70

5.7.1. Implementación Adaptative Retiming .................................................................. 70

5.7.2. Archivos SAIF (switching activity information) ................................................... 73

6. PROBLEMAS ........................................................................................................................... 75

3

7. ANÁLISIS DE RESULTADOS ............................................................................................... 77

7.1. Análisis de área ................................................................................................................. 77

7.1.1. Módulo de Encripción, reportes de Área a 20 ns. ..................................................... 77

7.1.2. Módulo de Encripción, reportes de Área a 30 ns. ..................................................... 78

7.1.3. Módulo de des-encripción, reportes de Área a 20 ns. ............................................... 78

7.1.4. Módulo de des-encripción, reportes de Área a 30 ns. ............................................... 79

7.2. Análisis de potencia estática ............................................................................................. 80

7.2.1. Análisis de potencia estática módulo de encripción 20ns ......................................... 80

7.2.2. Análisis de potencia estática módulo encripción 30ns .............................................. 81

7.2.3. Análisis de potencia estática módulo des-encripción 20ns ....................................... 83

7.2.4. Análisis de potencia estática módulo des-encripción 30ns ....................................... 84

7.3. Análisis de potencia dinámica ........................................................................................... 86

7.3.1. Análisis de potencia dinámica módulo encripción 20ns ........................................... 86

7.3.2. Análisis de potencia dinámica módulo encripción 30ns ........................................... 87

7.3.3. Análisis de potencia dinámica modulo des-encripción 20ns ..................................... 89

7.3.4. Análisis de potencia dinámica modulo des-encripción 30ns ..................................... 90

7.4. Comparación de resultados contra las metas de diseño..................................................... 92

7.4.1. Comparación módulo encripción potencia estática vs metas de diseño .................... 92

7.4.2. Comparación módulo encripción potencia dinámica vs metas de diseño ................. 93

7.4.3. Comparación módulo des-encripción potencia estática vs metas de diseño ............. 94

7.4.4. Comparación módulo des-encripción potencia dinámica vs metas de diseño ........... 95

7.4.5. Comparación del trougthput vs metas de diseño ....................................................... 96

7.5. Selección del diseño final .................................................................................................. 97

7.6. Trabajo futuro .................................................................................................................... 98

7.7. Anexos ............................................................................................................................... 98

8. CONCLUSIONES .................................................................................................................... 99

Bibliografía ..................................................................................................................................... 101

4

Índice de figuras Figura 2.1 Diagrama de bloques de un encriptor ...................................................................... 10

Figura 2.2 Matriz de estado .......................................................................................................... 16

Figura 2.3 Matriz de clave ............................................................................................................. 17

Figura 2.4 Diagrama de flujo encripción AES-128 .................................................................... 18

Figura 2.5 AddroundKey ............................................................................................................... 19

Figura 2.6 nueva matriz de estado .............................................................................................. 19

Figura 2.7 transformaciones S-Box [5] ........................................................................................ 19

Figura 2.8 Transformaciones por multiplicación S-box [5]. ...................................................... 20

Figura 2.9 Cuadro de sustitución S-box [5]. ............................................................................... 20

Figura 2.10 Cuadro de sustitución inversa S-box [5]. ............................................................... 21

Figura 2.11 Transformación ShiftRows en una matriz de estado. .......................................... 22

Figura 2.12 Transformación InvShiftRows en una matriz de estado. .................................... 22

Figura 2.13 Forma matricial ecuación 2.28 [5]........................................................................... 23

Figura 2.14 Forma matricial ecuación (2.35) [5] ........................................................................ 24

Figura 2.15 Clave de entrada guardada en el arreglo W [33]. ................................................ 26

Figura 2.16 Funcion RotByte ........................................................................................................ 26

Figura 2.17 Carga de un 1 lógico en un circuito [25] ................................................................ 28

Figura 2.18 Bloque de Pipeline [15]. ........................................................................................... 30

Figura 2.19 Diseño Combinacional.............................................................................................. 30

Figura 2.20 Diseño combinacional con auto pipe line .............................................................. 31

Figura 2.21 Diagrama testbench .................................................................................................. 31

Figura 2.22 Señales en una simulación ...................................................................................... 32

Figura 4.1 Metas de potencia Encripción y Des encripción ..................................................... 35

Figura 4.2 Metas de desempeño throughput ............................................................................. 35

Figura 4.3 Diagrama de bloques del algoritmo AES-128 ronda R ......................................... 36

Figura 4.4 ronda U del algoritmo AES-128 ................................................................................ 37

Figura 4.5 diagrama de bloques encripción AES-128 ............................................................. 37

Figura 5.1 Algoritmo AES-128 (a) Encripción (b) Des-Encripción .......................................... 39

Figura 5.2 Encripción AES-128 en C, (a) Texto de entrada (b) Encripción .......................... 41

Figura 5.3 Des-encripción AES-128 en C, (a) Texto de entrada, (b) Des-encripción ......... 43

Figura 5.4 Módulo AddroundKey en RTL ................................................................................... 44

Figura 5.5 Módulo ByteSub .......................................................................................................... 45

Figura 5.6 Transformación MixColumns ..................................................................................... 46

Figura 5.7 Matrices (a) Matriz de estado (b) Matriz MixColumns ........................................... 46

Figura 5.8 Matriz MixColumns ...................................................................................................... 47

Figura 5.9 Diagrama función X-TIME .......................................................................................... 48

Figura 5.10 Sub-módulo Comb1 .................................................................................................. 49



Figura 5.13 Sub-módulo C apreciar comb4 ............................................................................... 51

Figura 5.14 Módulo KeyExpansion .............................................................................................. 52

Figura 5.15 Sub- Módulo M4 ........................................................................................................ 52

5

Figura 5.16 Sub-Módulo NM4 ...................................................................................................... 53

Figura 5.17 Diagrama de bloques Des-Encripción Aes128 ..................................................... 54

Figura 5.18 Módulo R des-encripción Aes 128 .......................................................................... 55

Figura 5.19 Módulo U des-encripción Aes 128 .......................................................................... 55

Figura 5.20 Sub-Módulo Inv_Comb1 .......................................................................................... 56




Figura 5.24 Módulos Testbench ................................................................................................... 58

Figura 5.25 Simulación Aes Encripción ...................................................................................... 59

Figura 5.26(a) Datos de entrada (b) Clave Inicial (c) Datos Encriptados .............................. 59

Figura 5.27 Simulación Aes Des-Encripción .............................................................................. 60

Figura 5.28 Simulación Aes-128 Encripción y des-Encripción ................................................ 60

Figura 5.29 Testbench estructurado............................................................................................ 61

Figura 5.30 Testbench Aleatorio Encripción .............................................................................. 61

Figura 5.31 Testbench Algoritmo Encripción ............................................................................. 62

Figura 5.32 Testbench Aleatorio módulo Encripción ................................................................ 63

Figura 5.33 Testbench aleatorio módulo des-encripción ......................................................... 63

Figura 5.34 Testbench aleatorio de los módulos en serie. ...................................................... 64

Figura 5.35 Archivos de prueba (a) Imagen (b) Texto .............................................................. 64

Figura 5.36 Testbench de lectura de imagen ............................................................................ 65

Figura 5.37 (a) Archivo generado RTL (b) Archivo generado por C ................................... 66

Figura 5.38 Técnica adaptative retime ........................................................................................ 67

Figura 5.39 GUI Design compiler módulo encripción. .............................................................. 69

Figura 5.40 Implementación de un pipe de 4 stages ................................................................ 71

Figura 5.41 implementación de un pipe de 4 stages ................................................................ 71

Figura 5.42 movimiento de pipes (a) Netlist (b) Modo gráfico .............................................. 72

Figura 6.1 Circuito AES parte 1 .................................................................................................... 75

Figura 6.2 Circuito AES parte 2 .................................................................................................... 75

Figura 7.1 Gráficas de área del Encriptor a 20ns ...................................................................... 77

Figura 7.2 Gráficas de área del Encriptor a 30ns ...................................................................... 78

Figura 7.3 Gráficas de área del des Encriptor a 20ns .............................................................. 79

Figura 7.4 Gráficas de área del Des-Encriptor a 30ns ............................................................. 79

Figura 7.5 Gráficas de la potencia estática del Encriptor a 20 ns .......................................... 80

Figura 7.6 Gráficas de potencia estática leakage del Encriptor a 20 ns................................ 81

Figura 7.7 Gráficas de la potencia estática del Encriptor a 30 ns .......................................... 81

Figura 7.8 Gráficas de potencia estática leakage del Encriptor a 30ns ................................. 82

Figura 7.9 Gráficas de potencia estática del Des-Encriptor a 20ns ....................................... 83

Figura 7.10 Gráficas de potencia estática leakage del Des-Encriptor a 20ns ...................... 83

Figura 7.11 Gráficas de potencia estática del Des-Encriptor a 30ns ..................................... 84

Figura 7.12 Gráficas de la potencia estática leakage del Des-Encriptor a 30ns .................. 85

Figura 7.13 Gráficas de potencia dinámica del Encriptor a 20ns ........................................... 86

Figura 7.14 Gráficas de potencia dinámica leakage del Encriptor a 20ns ............................ 87

Figura 7.15 Gráficas de potencia dinámica del Encriptor a 30ns ........................................... 87

6

Figura 7.16 Grafica de potencia dinámica leakage del Encriptor 30ns ................................. 88

Figura 7.17 Grafica de potencia dinámica des-encripción 20ns ............................................. 89

Figura 7.18 Grafica de potencia dinámica leakage des-encripción 20ns .............................. 89

Figura 7.19 Grafica de potencia dinámica des-encripción 30ns ............................................. 90

Figura 7.20 Grafica de potencia dinámica leakage des-encripción 30ns .............................. 91

7

Índice de Tablas Tabla 2-1 Rotación ShiftRows. ..................................................................................................... 21

Tabla 4-1 Resultados de desempeño y potencia [29] .............................................................. 34

Tabla 4-2 Resultados de desempeño y potencia Basic Mem [29]. ........................................ 34

Tabla 6-1 división módulo encripción .......................................................................................... 76

Tabla 6-2 división módulo des-encripción .................................................................................. 76

Tabla 7-1 Resultados de potencia estática y metas de diseño ............................................... 92

Tabla 7-2 Resultados de potencia estática y metas de diseño. .............................................. 92

Tabla 7-3 Resultados de potencia dinámica prueba 1 y metas de diseño. ........................... 93







Tabla 7-10 Resultados de potencia dinámica prueba 2 y metas de diseño. ........................ 95



Tabla 7-13 Resultados de throughput y metas de diseño ....................................................... 96

Tabla 7-14 Resultados de throughput y metas de diseño ....................................................... 96

Tabla 7-15 resultados diseño final ............................................................................................... 97

8

Capítulo 1

1. INTRODUCCIÓN

La seguridad de la información siempre es un tema de todos los días, con el avance y el

acceso a la tecnología, la información requiere niveles de seguridad mucho más altos,

permitiendo a los usuarios mayor confiabilidad en los dispositivos o servicios de usos

diarios como: comunicaciones, internet, acceso a servicios bancarios entre otros.

La vulnerabilidad de la información, el descuido de las personas que tienen acceso a ella,

permiten que piratas informáticos, hackers, accedan a datos personales en

computadoras, o simplemente en la internet, es por esto que la encripción de datos hace

parte fundamental de las comunicaciones y la informática de los tiempos de hoy.

La encripción de la información data de los tiempos del emperador Julio Cesar, donde

para poder enviar información importante de guerra a sus altos mandos militares, sin que

fueran infiltrados si caían en manos del enemigo, el emperador corría cada letra del

alfabeto 3 lugares, es decir si iba a escribir una A escribía un C, de esta manera la

información solo podía ser decodificada por la persona que conocía la encripción.

En la era moderna las técnicas de encripción tienen que ser cada vez más robustas y

mucho más confiables, el algoritmo de encripción AES y la versión que se utiliza en este

trabajo de investigación es la ganadora Del concurso de 1997 [8] para encriptación, la

cual fue RIJNDAEL por tener un nivel de seguridad adecuado y por una sencilla

implementación [2]. Un tema importante que se tuvo en cuenta para la selección del

algoritmo es que fuera posible ser implementado tanto en software como en hardware.

Uno de los principales retos para los desarrolladores de hardware en esta era tecnológica,

es la implementación de procesadores cada vez más rápidos, más pequeños y que el

desempeño que muestren sea el mejor, ya que en este mundo competitivo la tecnología

cambia constantemente y cada día es más exigente en cuanto desempeño y portabilidad.

El manejo de video, audio cada vez más a la mano del usuario, hacen necesario que los

procesadores puedan manejar tiempo real para cada una de sus aplicaciones, ósea que

el desempeño de sus procesadores puedan brindar esas experiencias, es por esto que

para este trabajo el desempeño es una meta de diseño.

Con la llegada de los dispositivos móviles, se hace necesario que el uso de las baterías

sea el más eficiente y que su consumo sea óptimo, para brindar mejor servicio a los

usuarios convirtiéndolo en una necesidad para cualquier dispositivo.

9

Un aporte importante de esta investigación es el análisis que se realiza a nivel de RTL,

analizar cuál es el efecto o impacto directo que tiene la potencia sobre el desempeño del

circuito, también ver cuál es el efecto sobre el área si se garantiza un desempeño

determinado. Finalmente la investigación nos arroja resultados de potencia, área y

desempeño, pero la prioridad de este trabajo es de mantener una buena relación entre

desempeño y potencia, el área se analizó pero este parámetro no es prioridad para el

diseño.

Empresas como INTEL generan sus procesadores sobre las herramientas de diseño y de

simulación de synopsys, las cuales soportan la simulación de miles de millones de

transistores; ofrecen análisis profundos sobre desempeño, área y potencia. En este

trabajo de investigación se utilizaron para la síntesis del diseño, ya que ofrecen buenos

resultados.

La implementación del algoritmo está hecha en System Verilog y para el desarrollo de las

simulaciones se utilizó la herramienta Discovery Visualization Environment (DVE). Las

herramientas que se utilizaron para el análisis del desempeño fueron DESIGN

COMPILER, DESIGN VISION y el IC COMPILER, para los cuales se realizó análisis de

área, análisis de tiempo (timing) y análisis de potencia estática.

Para el análisis de potencia dinámica que es el análisis en toogle o switcheo del circuito

se utilizó el POWER COMPILER igual de synopsys, el cual mediante un benchmak o un

plan de pruebas, se estimuló el circuito con diferentes archivos lo que permitió analizar el

comportamiento del circuito cuando se encuentre encriptando.

10

Capítulo 2

2. MARCO TEÓRICO

2.1 Criptografía

Palabra que viene del griego cripto, que quiere decir ‘oculto’ y graphos, lo que plantea una

idea de su definición: el arte de escribir mensajes en clave secreta u oculta.

La criptografía es la técnica utilizada para cifrar un mensaje, sin que en el medio de

transmisión del mismo un agente externo a la comunicación, pueda obtener acceso al

mensaje sin cifrar.

El mensaje original es transformado mediante un procedimiento de cifrado controlado por una clave, en un mensaje cifrado, es decir el criptograma, que se envía a través de un canal público. El receptor con conocimiento de la clave transforma éste criptograma en el texto claro, recuperando la información original [5], ver figura 2.1.

Figura 2-2-1 Diagrama de bloques de un encriptor

Los algoritmos criptográficos son funciones matemáticas usadas tanto por las técnicas para cifrado y descifrado de datos, como por aquellas herramientas relacionadas con la firma digital y las funciones de integridad. En la criptografía moderna estos algoritmos son públicamente conocidos y su seguridad se apoya en el conocimiento de algún elemento secreto llamado clave o llave [5].

Existen dos tipos de algoritmos basados en claves:

1. Simétricos (Clave privada)

2. Asimétricos (Clave pública)

Figura 2.1 Diagrama de bloques de un encriptor

11

Los algoritmos simétricos comparten una única clave tanto para encriptar como para des-

encriptar, un ejemplo es el algoritmo de encripción AES; la seguridad del sistema reposa

en mantener el secreto de la clave. Una de las vulnerabilidades más importantes de los

sistemas simétricos es encontrar un medio confiable para poder intercambiar la clave de

manera segura, ya que con la clave se puede tener acceso al mensaje original. Este tipo

de cifradores a su vez, se dividen en dos clases: bloque y flujo continuo.

Los cifradores de bloque dividen el mensaje de texto pleno a transmitir en bloques de tamaño fijo y cifran uno a la vez. En este sentido poseen similitudes con códigos para corrección de errores. Existen dos clases de cifradores de bloque: por sustitución y por transposición [1]. Los cifradores por sustitución simplemente reemplazan símbolos por otros símbolos o por grupos de ellos. El problema de este tipo de cifradores es que en el texto cifrado se reflejan las propiedades de frecuencia de aparición de determinadas letras que caracterizan al idioma particular del texto pleno. Los cifradores por transposición realizan permutaciones de símbolos que pertenecen al mismo bloque. Obviamente, este tipo de cifradores no proveen un nivel de seguridad elevado cuando se utilizan de manera individual [1]. Por su parte, los cifradores de flujo continuo son una clase particular de cifradores bloque que utilizan un tamaño de bloque unitario. De este modo es factible cambiar la transformación de cifrado o la clave particular para cada símbolo de texto pleno a cifrar. Son muy aplicables en situaciones donde la probabilidad de error de la transmisión es muy elevada ya que no poseen errores de propagación [1].

Con el pasar de los años y la llegada de las computadoras, los algoritmos diseñados en la

época de los años 80’s y 90’s eran muy frágiles de vulnerar con las operaciones que

podían hacer las computadoras, además de que los algoritmos de encripción utilizados

eran muy sencillos y su seguridad estaba basada en el tamaño de la clave. En la época

actual, la fortaleza del encriptor no sólo se basa en el tamaño de su clave sino también en

la calidad del cifrado.

A comienzos de este siglo, el (NITS) National of Standards and Technology decide

trabajar en la implementación de un estándar de encripción llamado Advanced Encryption

Standard (AES), con lo cual su objetivo final era lograr especificar un algoritmo de

encripción robusto para la protección de la información, algoritmo que iba a ser utilizado

por el gobierno de los Estados Unidos [1], para lo cual se realizó una gran convocatoria

para escoger el nuevo estándar de encripción.

Algunos de los algoritmos presentados para ser evaluados fueron MARS [1] [2], RC6 [2],

Serpent [1] [2] y Twofish [1] y fueron descartados por presentar poca eficiencia,

vulnerabilidad a los ataques conocidos de la época y algunos por su complejidad

haciéndolos poco eficientes.

El algoritmo escogido en octubre del 2000 fue Rijndael, que es un sistema simétrico de

cifrado por bloques, por tanto utiliza la misma clave para el proceso de cifrado como para

12

el proceso de descifrado. Su diseño permite la utilización de claves de sistema con

longitud variable, siempre que sea múltiplo de 4 bytes. La longitud de las claves utilizadas

por defecto son 128 (AES128), 192 (AES192), 256 (AES256) bits. [8]

Algunos aspectos importantes del porqué fue escogido como el mejor algoritmo por el

Instituto Nacional de Normas y Tecnología (NIST) fueron:

Su implementación puede ser ejecutada a velocidades elevadas para cifradores en bloque.

Las operaciones por ronda se pueden paralelizar siendo así una ventaja para la implementación en hardware.

La portabilidad de su diseño permite la implementación tanto en hardware como en software.

Las transformaciones Shiftrows y Mixcolumns permiten obtener un alto nivel de difusión a lo largo de varias rondas.

La transformación ByteSub proporciona una sustitución con propiedades de no linealidad.

La adición de llave o subclaves permite generarlas partiendo de la clave del usuario para ser usadas en cada roda del algoritmo.

2.2. Matemática preliminar

Las operaciones basadas en el algoritmo de RIJNDAEL se realizan a nivel de byte,

representadas mediante un campo llamado GF ( ) y a nivel de registros de 32 bits.

Vamos a definir las operaciones matemáticas necesarias para poder definir o resolver el

algoritmo de encripción Rijndael.

2.2.1. Campos finitos

Todos los elementos del algoritmo son representados como elementos de un

cuerpo finito, estos elementos se representan mediante los campos finitos de Galois

GF(k) (“Galois Field”).

Para todo primo p y entero positivo n, hay exactamente un campo finito de orden

. Por lo común se refiere a este campo GF ( ) como el campo Galois de orden , en

este conjunto todos los elementos menos el cero tienen inversa, por tanto se pueden

realizar operaciones suma, resta, multiplicación y división de la misma forma que en los

reales [5].

En criptografía son dos casos los que más se usan: q = p, con p un número primo

y q = 2m. El caso formado, GF(p), es denotado como el campo primo, considerando el

http://es.wikipedia.org/wiki/Instituto_Nacional_de_Normas_y_Tecnolog%C3%ADa

13

anterior, GF(2m), es conocido como el campo finito de característica dos o simplemente

un campo binario [5].

2.2.2. Representación de polinomio

Para este caso (Rijndael) el campo de Gaolis es representado como GF ( ),

donde sus elementos son representados como polinomio con coeficientes en de grado

menos que m [8], es decir:

( )

(2.1)

Cada elemento de ( ) es un resto módulo p(x), donde p(x) es un polinomio

irreducible de grado “m”, esto es que no puede ser factorizado en polinomios de grado

menor “m”.

2.2.3. Representación Campo GF ( )

El campo GF ( ) es un campo finito en el que los elementos (bytes) son

representados como polinomios de grado 7 con coeficientes binarios {0,1}, es decir:

(2.2)

Donde b puede tomar los valores binarios 1 o 0.

El polinomio se puede escribir de la siguiente manera:

(2.3)

Si quisiéramos representar el en un polinomio del campo GF ( )

obtendríamos:

(2.4)

Reescribiendo:

(2.5)

2.2.4. Suma en el Campo GF ( )

La suma de dos elementos del campo GF ( ) es la suma de dos polinomios por lo

que el resultado será otro polinomio, esta suma es una suma en módulo 2 término a

término, para la suma basta con aplicar la operación Or-Exclusiva a cada uno de los

elementos del polinomio.

14

Un ejemplo de la suma de dos polinomios en el campo ( )

(2.6)

(2.7)

(2.8)

2.2.5. Multiplicación en el Campo GF ( )

La multiplicación en el campo GF ( ) es lo mismo que la multiplicación de dos

elementos o dos polinomios, pero la característica fundamental es que la multiplicación se

debe realizar módulo con un polinomio irreducible de grado 8, este polinomio es

irreducible ya que sus únicos divisores son el 1 y el mismo, la idea de hacer este módulo

con el polinomio irreducible es que el resultado se mantenga en el campo GF ( ).

El polinomio irreducible está representado por m(x):

( ) (2.9)

Si realizamos la multiplicación entre

( ) ( ) (2.10)

( ) ( ) (2.11)

(2.12)

El resultado de la multiplicación anterior se encuentra fuera del campo GF ( ) así

que hay que hacer el módulo con m(x)

( ) ( ) ( )

(2.13)

( ) (2.14)

Todo valor que se encuentre fuera de los 8 bits, estará por fuera del campo GF

( ), y se deberá hacer módulo m(x) para su representación en GF ( ).

2.2.6. Multiplicación por x

Este caso es muy útil ya que de aquí se desprende la solución en software de la

multiplicación para cuando el resultado está por fuera del campo GF ( ). Si multiplicamos

un polinomio ( ) por x es decir:

15

( ) (

) (2.15)

( ) (

) (2.16)

Dependiendo del valor que tenga habrá que reducirlo o no con el módulo m(x),

es decir si el resultado es el mismo polinomio, pero si , hay que reducir el

valor

Muchos autores [6,][8],[3] definen la multiplicación con una función llamada “xtime”

que realiza la multiplicación de un polinomio del campo GF ( ) por dos, analizando si el

polinomio a multiplicar debe ser normalizado al campo GF ( ) partiendo del bit más

significativo del polinomio.

La función ‘xtime’ simplifica la multiplicación por dos, lo que hace es realizar un

desplazamiento a nivel de bits (a la izquierda) y una operación de Or-exclusiva con el

valor 0x11B (( ( ) =000100011011) únicamente cuando el valor

debe ser reducido en caso de que no pertenezca al campo GF ( ), la función es la

siguiente:

Int xtime (int valor)

{

Valor = Valor < <1;

If(Valor&0x100)

Valor^=0x11B;

Return Valor;

}

Al ejecutar la función ‘xtime’ equivale a multiplicar el polinomio por dos; la

importancia de esta función es que permite realizar la multiplicación del polinomio sin

necesidad de realizar la operación módulo con el polinomio irreducible m(x). Si

realizáramos la siguiente multiplicación

( ) ( ) (2.17)

Aplicando la propiedad asociativa para podríamos descomponer en potencias

de x de la siguiente manera:

(2.18)

Por lo tanto:

( ) ( ) ( ) (2.19)

16

Lo que se traduce inmediatamente en multiplicaciones por dos, siendo lo que la

función ‘xtime’ realiza y normaliza automáticamente al campo GF ( ),

Resolviendo las multiplicaciones

( ) (2.20)

( ( ( ))) (2.21)

(2.22)

Al final el resultado de la multiplicación vendrá dado por Or-exclusiva de los tres

resultados anteriores. Lo que permite ver con claridad que cualquier multiplicación puede

ser realizada con la función ‘xtime’ aplicando el principio de asociación en los polinomios.

2.3. Algoritmo de encripción Rijndael

El algoritmo Rijndael es un sistema simétrico de cifrado por bloques, por tanto utiliza la

misma clave para el proceso de cifrado como para el proceso de descifrado. Su diseño

permite la utilización de claves de sistema con longitud variable siempre que sea múltiplo

de 4 bytes. La longitud de las claves utilizadas por defecto son 128 (AES128), 192

(AES192), 256 (AES256) bits. [8]

El algoritmo utiliza un tamaño determinado de información de entrada, esa información

es llamada “estado”, el “estado” es una matriz rectangular de bytes, que tiene 4 filas y Nb

número de columnas, donde Nb es el tamaño del bloque:

(2.23)

Para este caso, como el tamaño del bloque que se utilizó es de 128 bits Nb es de

4 la matriz de estado es de 4x 4 como se ve en la figura 2.2

Figura 2.2 Matriz de estado

La clave del sistema tiene una estructura similar a matriz de estado ya que la clave

será siempre del mismo tamaño de la matriz de estado y se puede calcular de una

manera muy similar:

17

(2.24)

La representación de la matriz de la clave teniendo en cuenta un tamaño de

bloque 128 se aprecia en la figura 2.3

Figura 2.3 Matriz de clave

Luego de tener definidas las matrices de entrada correspondientes a los datos a encriptar

y a la clave de entrada, a partir de este momento la matriz de estado sufre 4

transformaciones por ronda, mientras la clave es necesaria para generar una sub clave

por ronda, las transformaciones son:

1. AddroundKey: Cada byte de la matriz de estado es operada mediante XOR con la clave, según la ronda en la que se encuentre el algoritmo.

2. ByteSub: es una sustitución no lineal donde cada byte es remplazado de acuerdo a una tabla de búsqueda llamada S-BOX.

3. ShiftRows: Es una transposición donde cada fila de la matriz de estado es rotada un determinado número de veces según la fila de la matriz de estado. MixColumns: Es un mezclado que opera en las columnas de la matriz de estado

combinando los cuatro bytes en cada columna usando una transformación lineal.

El número de iteraciones del algoritmo está dado por:

( ) (2.24)

Para diferentes tamaños de clave y de estado tendríamos:

( ) (2.25)

(2.26)

18

2.3.1. Cifrado Rijndael

De una manera gráfica el diagrama de flujo del cifrado sería:

Figura 2.4 Diagrama de flujo encripción AES-128

En la figura 2.4 podemos apreciar el orden que deben implementar las cuatro

transformaciones para realizar la encripción de la matriz de estado, ahora se describirán

cada una de las transformaciones.

19

2.3.1.1. Función AddRoundKey

La transformación AddRoundKey consiste en realizar la operación Or-Exclusiva entre la

matriz de estado y la clave dependiendo la ronda en la que esté pasando el algoritmo, ya

que puede ser una de las sub-claves generadas por el módulo de expansión de la clave.

A continuación en la figura 2.5 se muestra gráficamente la función AddRoundKey:

Esta función realiza la Or-Exclusiva entre cada uno de los elementos de las 2 matrices de

como se aprecia en la figura 2.6

Dependiendo de la ronda de la cual esté pasando el algoritmo la clave será sacada de la

función expansión de la clave, función que genera una clave por ronda.

2.3.1.2. Función ByteSub

La transformación ByteSub consiste en una sustitución no lineal que se aplica a cada byte

de la matriz de estado que de manera independiente genera un nuevo byte [8].Figura 2.7

Figura 2.5 AddroundKey

Figura 2.6 nueva matriz de estado

Figura 2.7 transformaciones S-Box [5]

20

La S-Box se obtiene componiendo dos transformaciones [5]:

1. Cada byte es considerado como un elemento del GF ( ), que genera el polinomio irreducible m(x) = x + x + x + x + 1, y sustituido por su inversa multiplicativa. El valor cero queda inalterado [5]. 2. Se aplica la siguiente transformación, siendo x0, x1,..., x7 los bits del byte al que se va a aplicar la transformación y cuyo resultado se da en y0, y1,..., y7 [5]. Se aprecia la figura 2.8

Figura 2.8 Transformaciones por multiplicación S-box [5].

Después de las dos transformaciones anteriores el resultado es la tabla de reemplazo S-

Box, con la que se realiza la sustitución ByteSub. La tabla S-Box (figura 2.9) se ve a

continuación:

Figura 2.9 Cuadro de sustitución S-box [5].

21

Para el proceso de descifrado es necesario calcular la función inversa de ByteSub, Esta

función inversa consiste en calcular una tabla inversa a la utilizada en el proceso de

cifrado. Tabla inversa S-Box [8] se aprecia en la figura 2.10:

Figura 2.10 Cuadro de sustitución inversa S-box [5].

2.3.1.3. Función ShiftRow

Esta transformación consiste en rotar las filas de la matriz de estado, un determinado

número de veces hacia la izquierda, este estado hace parte de la transformación 3 y la

matriz de estado que entra a esta transformación 0 es la salida de la transformación

ByteSub.

Dependiendo del tamaño del bloque se realiza la rotación de las filas, en la figura 9 se

puede apreciar el número de veces que se debe realizar la rotación dependiendo el

tamaño del bloque:

Tamaño del Bloque Fila 1 Fila 2 Fila 3

128 bits (Nb = 4) 1 2 3

192 bits (Nb = 6) 1 2 3

256 bits (Nb = 8) 1 3 4

Tabla 2-1 Rotación ShiftRows.

Es importante aclarar que la fila 0 no sufre ningún tipo de rotación, las únicas afectadas

son las filas 1, 2 y 3 como se puede apreciar en la figura 2.11:

22

En la figura 2.11 se muestra la transformación que sufre la matriz de estado al pasarla por

la función ShiftRows.

2.3.1.4. Función InvShiftRow

La función InvShiftRow que es la función inversa de ShiftRows consiste en hacer una

rotación de filas hacia la derecha dependiendo de la fila a la que se le vaya aplicar la

transformación, de forma gráfica en la figura 2.12 se aprecia cómo se rotan las filas:

La fila 0 se mantiene sin rotar al igual que en la función ShiftRow, mientras que la fila 1 es

rotada una posición a la derecha en la matriz de estado, la fila 2 es rotada dos posiciones

a la derecha y la fila 3 finalmente es rotada tres posiciones a la derecha en la matriz de

estado, todo esto para un bloque de entrada de 128 bits, para los otros casos de tamaño

de bloque la rotación está especificada en la tabla 2.1.

2.3.1.5. Función MixColumns

La transformación MixColumns opera columna por columna en la matriz de estado, trata cada columna como un polinomio de cuatro términos. Las columnas son consideradas como polinomios sobre GF(28) y multiplicadas por un polinomio fijo a(x) módulo x4 + 1 [1]. El polinomio a(x) está dado por:

( ) (2.27)

Esto también puede escribirse como la multiplicación de una matriz:

Figura 2.11 Transformación ShiftRows en una matriz de estado.

Figura 2.12 Transformación InvShiftRows en una matriz de estado.

23

( ) ( ) ( ) (2.28)

Donde ( ) representa la matriz de estado después de la transformación MixColumns,

( ) la matriz de estado que es el resultado de la transformación ShiftRows para la

encripción.

Representando la ecuación de forma matricial obtenemos la figura 2.13.

Figura 2.13 Forma matricial ecuación 2.28 [5]

Desarrollando la matriz de la figura 2.13 para obtener la nueva matriz de estado

obtenemos:

( ) ( ) (2.29)

( ) ( (2.30)

( ) ( ) (2.31)

( ) ( ) (2.32)

Este procedimiento se debe realizar para todas las columnas de la matriz de estado.

2.3.1.6. Función InvMixColumns

La función inversa InvMixcolumns se obtiene de la multiplicación de la matriz de estado

por el polinomio d(x):

( ) (2.33)

Este polinomio, permite realizar la inversa del polinomio ya que se cumple que:

( ) ( ) (2.34)

24

Reescribiendo la transformación InvMixColumns de forma matricial obtenemos:

( ) ( ) ( ) (2.35)

Figura 2.14 Forma matricial ecuación (2.35) [5]

( ) ( ) ( ) ( ) (2.36)

( ) ( ) ( ) ( ) (2.37)

( ) ( ) ( ) ( ) (2.38)

( ) ( ) ( ) ( ) (2.39)

Este procedimiento se debe realizar para todas las columnas de la matriz de estado al

igual que en la transformación MixColumns.

2.3.1.7. Función de expansión de la clave

Cada vez que voy a utilizar la función AddroundKey se necesita una nueva clave para

calcular la nueva matriz de estado, es por esto que en esta función se generan todas las

subcalves para cada una de las rondas en el código, el número de subclaves también

depende del tamaño del bloque, el número total de subclaves se calcula de la siguiente

forma:

(2.40)

Dónde:

Nr: Numero de Rondas previamente calculado en la ecuación 2.26.

25

2.3.1.7.1. Selección de la clave

La función de selección de la clave toma consecutivamente las subclaves generadas por

la expansión de la clave tomando bloques del mismo tamaño de la matriz de estado, en

forma general se dice que toma Nb*4 bytes para cada ronda.

Para el proceso de descifrado la selección de la subclave se realiza de forma diferente, ya

que para empezar a realizar la función de InvAddroundKey, la clave que se selecciona es

la última generada por la función de expansión de la clave y la siguiente de manera

decremental hasta llegar a la primera clave que es la ingresada por el usuario.

2.3.1.7.2. Expansión de la clave

La función de expansión de la clave permite generar las subclaves partiendo de la clave

del sistema K, todas las subclaves son guardadas en un array lineal llamado W, de cuatro

filas y la longitud de columnas se puede calcular de la siguiente manera:

( )

Donde Nc es el número de columnas de la matriz de estado, Nr el número de rondas del

algoritmo, para un bloque de 128 el número de columnas es 44.

Las primeras Nk palabras del array contienen la clave de entrada del sistema, mientras

que las siguientes palabras son generadas por la función de expansión, los autores [1], [2]

definen el siguiente seudocódigo para la generación de la subclave:

KeyExpansion(byte Key[4 * ] Word [ ( )]

For (i=0 ; i < Nk ;i ++)

{

W[i]=(key[4*i],key[4*i+1],key[4*i+2],key[4*i+3]);

For(i= ; i < * ( ) ; i++)

{

Temp = W[i-1];

If (i % ==0)

{

Temp=SubByte (RotByte (temp)) ^ Rcon [

] ;

http://espanol.answers.yahoo.com/question/index?qid=20060918181540AA8aXBv

26

W[i]=W[i- ] ^temp;

}

El código lo podemos dividir en cuatro pasos:

1. La clave ingresada por el usuario es copiada en el arreglo W como se aprecia

en la figura 2.15.

Figura 2.15 Clave de entrada guardada en el arreglo W [33].

2. Se toma la columna W[i-1] para generar las subclaves, para esto se verifica si

la columna por analizar es múltiplo de , en caso de que sí sea múltiplo la

columna seleccionada sufre tres transformaciones:

SubByte

RotByte

Rcon

SuBbyte: esta transformación es idéntica a la que sufre la matriz de estado

en el proceso de encripción, intercambia los bytes de la matriz con la tabla

S-Box

RotByte: Rota el byte 0 de la columna que está sufriendo la transformación

como se aprecia en la figura 2.16:

Figura 2.16 Funcion RotByte

27

RCON: es una sustitución de acuerdo a la siguiente forma:

[ ] ( [ ] ) (2.41)

Desde el punto de vista polinomial:

RC[1]=1 RC[6]=

RC[2]= x =2 RC[7]=

RC[3]= RC[8]=

RC[4]= RC[8]=

RC[3]= RC[8]=

3. Se resuelve el resultado de las tres transformaciones haciendo X-OR de los

resultados de las mismas.

4. En caso en que la columna por analizar no sea múltiplo de 4, las

transformaciones anteriores no se realizan, y sólo se hace un X-OR con la

columna W [i-4], como se ve en el siguiente código.

temp = W[i-1];

W[i]=W[i-4]^temp;

2.4. Potencia

La potencia disipada en un circuito se divide en dos categorías:

Potencia estática

Potencia dinámica

2.4.1. Potencia estática

La potencia estática es la disipación de energía en una compuerta cuando no se

encuentra switchando o conmutando, esto quiere decir que se encuentra inactiva o

estática [23].

El mayor porcentaje de la potencia estática disipada resulta desde source al drain, el

cual es reducido por los voltajes de threshold que previenen que la compuerta se

apague completamente. La potencia estática también es disipada cuando la corriente

de fuga pasa entre las capas de difusión del sustrato.

28

2.4.2. Potencia dinámica

La potencia dinámica es disipada cuando el circuito se encuentra activo, la tensión

sobre una red del circuito cambia en cualquier momento debido a los estímulos

aplicados al circuito.

La potencia dinámica se produce con la carga y descarga de un condensador, este

condensador se carga para tomar un valor de uno y cuando se descarga, toma el valor

de cero a la salida Vout, como se puede apreciar en la figura 2.17:

Figura 2.17 Carga de un 1 lógico en un circuito [25]

Dónde:

CL: Condensador de carga en el circuito

La energía por transición que ocurre con la carga y descarga del condensador está dada

por:

(2.42)

Dónde:

: Enegria acumulada en el condensador

Vdd: Voltaje de alimentación (Voltage drenador)

La potencia dinámica viene dada por:

(2.43)

(2.44)

Como se puede apreciar en la ecuación 2.44 no es función del tamaño de los transistores,

pero sí es función de la carga, una técnica de reducción de potencia utilizada es bajar la

capacitancia, con esto, se lograría bajar el área y el retardo en el circuito, otra variable a

manejar es la frecuencia, el inconveniente de bajar la frecuencia es que esta variable es

29

directamente proporcional al desempeño; una de las técnicas más utilizadas para bajar la

potencia es reducir el voltaje alimentación.

2.4.2.1. Corriente de corto circuito

En el momento en que los dos transistores de un inversor se encuentran encendidos, ya

sea en región de saturación o en tríodo, hay una corriente que fluye desde fuente a tierra,

que no va a pasar por la capacitancia de salida. Cuando se encuentra en estado estable,

siempre estará un transistor prendido mientras el otro se encuentra apagado y toda la

corriente va fluir hacia la carga.

2.4.2.2. Corriente de Leakage

Es la corriente que fluye a través de los diodos, cuando se encuentran polarizados de

forma inversa. El leakage está directamente relacionado con el proceso de fabricación,

esta puede ser reducida con el tamaño de los diodos. Una forma de combatir este tipo de

corriente es apagándolos en los momentos en que no se vayan a utilizar.

2.5. Pipeline

La segmentación (pipelining) es un método por el cual se consigue aumentar el

rendimiento de sistemas digitales. Es aplicado, sobre todo, en microprocesadores. Un

ejemplo claro puede ser que el gas en un oleoducto, a la máxima velocidad es necesario

dividirlo en tramos y colocar una bomba que dé un nuevo impulso al gas. El símil con la

programación existe en que los cálculos deben ser registrados o sincronizados con el reloj

cada cierto tiempo, para que la ruta crítica (tramo con más carga o retardo computacional

entre dos registros de reloj) se reduzca [15].

La ruta crítica es en realidad la frecuencia máxima de trabajo alcanzada por el conjunto. A

mayor ruta crítica (tiempo o retraso entre registros) menor es la frecuencia máxima de

trabajo y a menor ruta crítica mayor frecuencia de trabajo. La una es la inversa de la otra.

Repartir o segmentar equitativamente el cálculo hace que esa frecuencia sea la óptima a

costa de más área para el almacenamiento o registro de los datos intervinientes y de un

retraso o latencia (en ciclos de reloj/tiempo) en la salida del resultado equivalente al

número de segmentaciones o registros realizados. La ventaja primordial de este sistema

es que, tal y como se muestra en la figura 2.18, una vez el pipe está lleno, es decir,

30

después de una latencia de cuatro en la figura 2.18, los resultados de cada comando

vienen uno tras otro, cada flanco de reloj y sin latencia extra por estar encadenados

dentro del mismo pipe. Todo esto habiendo aumentado a la frecuencia máxima de trabajo

[15].

Figura 2.18 Bloque de Pipeline [15].

2.6. Auto Pipeline

La técnica de auto pipeline es una técnica propia de las herramientas de síntesis, que se

encargan de analizar en qué parte del circuito se encuentra la carga más alta de

componentes combinacionales y pone una línea de pipes, para mitigar el impacto que

tiene sobre la potencia y el desempeño del circuito, dependiendo las metas del diseño.

En la figura 2.19 se aprecia un diseño completamente combinacional:

Figura 2.19 Diseño Combinacional

Diseño

Combinacional

31

Después de realizar el proceso de auto pipeline, en el momento de realizar la síntesis el

software dependiendo de las líneas de pipes que se quieran colocar por el usuario, el

software divide el circuito y su salida se puede apreciar en la figura 2.20:

Figura 2.20 Diseño combinacional con auto pipe line

La figura 2.20 se puede apreciar el circuito dividido con dos pipe-lines, esta técnica

permite la reducción de potencia ya que el circuito no debe resolver todas las operaciones

en un sólo ciclo de reloj, sino que usa pipes para resolverlos en ciclos determinados, esta

técnica es implementada en este trabajo de investigación para la parte de optimización de

potencia.

2.7. Testbench

El testbench tiene como propósito el de generar los estímulos que excitará el circuito bajo

prueba, escribir testbench es igual de complejo que escribir el rtl ya que debe cumplir

exactamente los mismos requisitos que el rtl que fue diseñado.

En la figura 2.21 se puede apreciar cómo las salidas del testbench son las entradas del

DUT (Device Under Test) este DUT es el diseño en rtl, y las salidas del DUT son las

entradas del testbench, esto con el fin de verificar la funcionalidad del diseño.

Hay varias etapas de verificación o de diseño de testbench:

Test básico: este tipo de test lo que se encarga es de excitar el DUT para verificar la

interconectividad del diseño y observar los resultados.

Figura 2.21 Diagrama testbench

32

Test medio: este tipo de test se encarga de excitar el circuito o DUT, y verificar las salidas

del diseño para comprobar la funcionabilidad del mismo.

Test avanzado: este tipo de test se encarga de excitar el circuito, verificar las salidas y

realizar un cubrimiento de todos los posibles movimientos del diseño, para así lograr un

cubrimiento por encima del 90% de todas las señales del circuito, y garantizar su

funcionamiento total en caso de llevarlo al proceso de fabricación.

Como el testbench debe verificar el funcionamiento del circuito, este mismo debe de

realizar exactamente lo mismo que se describe en rtl, una ventaja importante de los

testbench es que este código no es sintetizable, lo que permite escribir el diseño en alto

nivel y realizar la comprobación del circuito con un código diferente al diseñado en rtl.

Figura 2.22 Señales en una simulación

En la figura 2.22 se puede apreciar la simulación de un circuito donde sus señales son

generadas por el testbench.

La comprobación del funcionamiento del circuito no es más que la comparación del

modelo de referencia testbench con el circuito en rtl, si el resultado de estos dos diseños

es diferente, se debe reportar para realizar los ajustes al rtl, aclarando que el testbench

debe estar bien escrito para realizar esta comparación.

El testbench puede ser escrito en diferentes lenguajes de alto nivel como C, Sytem C,C++

Specman, Vera , Phyton entre otros, lo que hace del testbench una herramienta poderosa

de verificación.

33

Capítulo 3

3. OBJETIVOS

3.1 Objetivo general

Implementar un diseño en RTL que garantice una buena relación de desempeño y

potencia del algoritmo de encriptación AES-128.

3.2 Objetivos específicos

Implementar el algoritmo AES en C como referencia para luego ser implementado como Testbench para la verificación funcional del RTL.

Implementar el algoritmo AES en VERILOG para el análisis de bajo nivel.

Sintetizar el RTL para el análisis del hardware a nivel de área, potencia, desempeño y ajustar el RTL para alcanzar las metas de desempeño y potencia.

Analizar y comparar los resultados obtenidos con las mejoras del RTL a nivel de potencia y desempeño contra los resultados de la tabla 4.2.

Realizar un registro de pruebas con archivos de diferentes tipos para poder medir el desempeño del RTL y analizar las mejoras sobre el mismo.

Analizar los resultados del registro de pruebas y seleccionar la mejor opción del diseño.

34

Capítulo 4

4. ESPECIFICACIONES

El sistema a ser diseñado es la implementación en RTL del algoritmo de encripción AES-

128, mejorando los resultados en potencia y desempeño de la versión Basic mem del

trabajo de investigación titulado “Energy efficiency analysis and implementation of aes on

an fpga” [29]. Los resultados de este trabajo se pueden apreciar en la tabla 4.1

Tabla 4-1 Resultados de desempeño y potencia [29]

Los resultados de la tabla 4.1 muestran la potencia dinámica y la potencia estática

de la encripción y la des encripción, para todos los diseños del trabajo de investigación

[29], corriendo a la frecuencia máxima de operación del diseño; También se encuentran

los valores de desempeño para todos los diseños.

Partiendo de los resultados del trabajo “Energy efficiency analysis and implementation of

aes on an fpga” [29], en este trabajo se realizará una comparación de una implementación

en una FPGA a un diseño de un procesador desarrollado sobre las herramientas de

synopsys.

Los resultados a mejorar serán el desempeño y potencia de la implementación Basic

Memory Based Cipher del trabajo de investigación “Energy efficiency analysis and

implementation of aes on an fpga” [29], que se pueden apreciar en la tabla 4.2.

Tabla 4-2 Resultados de desempeño y potencia Basic Mem [29].

35

A continuación se muestran las metas de diseño que hay que superar en cuanto a

potencia Figura 4.1 Encripción y Des Encripción:

Figura 4.1 Metas de potencia Encripción y Des encripción

A continuación se muestran las metas de diseño que hay que superar en cuanto a

Desempeño throughput Figura 4.2 Encripción y Des Encripción:

Figura 4.2 Metas de desempeño throughput

0

50

100

150

200

Potencia Estatica

mW Potencia Dinamica

mW

80,98

191,98

80,98

192,05

Metas de potencia

Des Encripcion

Encripcion

0

100000

200000

300000

400000

500000

600000

Tp Max(Mbps)

Performance(Mbps)

2560

512.000

2560

512.000

Metas de Desempeño

Des Encripcion

Encripcion

36

El diagrama de flujo del algoritmo de encripción se puede apreciar en Figura 2.2, el

inconveniente de realizar una implementación con este diagrama de flujo es que para

poder obtener un dato encriptado, si es la versión AES 128 tengo que esperar 10 rondas,

lo que hace que el procesador este completamente ocupado durante el número de ciclos

que tarde en resolver el algoritmo por 10, a continuación se muestra el diagrama a

implementar en este trabajo, figura 4.3:

Figura 4.3 Diagrama de bloques del algoritmo AES-128 ronda R

En la figura 4.3 se muestra a la entrada la primera transformación que sufren los datos

que es AddroundKey, y el bloque R que cuenta con las transformaciones ByteSub,

MixColumns y AddroundKey, el bloque R se replicara 9 veces para cumplir con todas las

transformaciones del algoritmo AES-128, ya que el número de rondas del algoritmo esta

dado:

( ) (4.1)

Donde

= tamaño del bloque de la clave

= tamaño del bloque de entrada

Para un bloque de 128 Nb y Nk es 4 así que:

La décima ronda del algoritmo se puede ver en la figura 4.4

37

Figura 4.4 ronda U del algoritmo AES-128

En la figura 4.4 se puede apreciar la ronda U que contiene las transformaciones

AddroundKey, ByteSub y la expansión de la clave, esta es la última ronda para finalizar la

encripción de los datos, de manera general el diagrama de bloques completo del

algoritmo se puede apreciar en la figura 4.5:

Figura 4.5 diagrama de bloques encripción AES-128

En la figura 4.5 se puede apreciar como re replican las rondas R 9 veces y al final se

agrega la ronda U, para cada ronda se hace la expansión de la clave necesaria. La

entrada de datos a la ronda 1 debe ser la salida de la transformación Addroundkey con la

clave inicial y datos a encriptar.

Cabe resaltar que de esta manera no es necesario esperar a que un dato sea encriptado

para poder ingresar un nuevo dato a encriptar ya que cada ronda es independiente como

se puede apreciar en la figura 4.5.

38

Capítulo 5

5. DESARROLLO

Para el desarrollo del trabajo de investigación se implementó la siguiente metodología de

trabajo:

Implementación del algoritmo de encripción y des-encripción AES-128 en C, que

servirá de referencia para el desarrollo del RTL, y que será utilizado para la

verificación en el Testbench.

Implementación en RTL del algoritmo AES-128 de encripción y des-encripción.

Realización del Testbench del RTL para verificar el funcionamiento del algoritmo

de encripción y des-encripción.

Síntesis del diseño en RTL para cálculo de área, potencia y desempeño.

5.1. Implementación del algoritmo AES-128 en C.

La implementación del algoritmo fue realizada sobre la herramienta DEV C++, el diagrama

de flujo utilizado para la encripción y des-encripción se puede apreciar en la figura 5.1:

39

(a) (b)

En la figura 5.1 (a) vemos el diagrama de flujo de la implementación del algoritmo de

encripción, que fue la base de la implementación en C, las funciones que se utilizaron en

la encripción se pueden ver en el siguiente código:

Main ()

{

Figura 5.1 Algoritmo AES-128 (a) Encripción (b) Des-Encripción

40

/************************************************************/

/* ENCRIPCION */

/************************************************************/

Datos_iniciales(); //Texto a encriptar, clave y

matrices para el proceso

KeyExpansion (key,W);

AddRoundKey(estate,W,v);

For(v=0;v<(Nr-1);v++) // 9 rondas de clave para 128

bits

{

Subytes (estate);

Shiftrounds (estate);

Mixcolumns (estate,matriz_mixcolumns);

AddRoundKey(estate,W,v);

}

Printf("********************************\n");

Printf(" Ronda Final \n");

Printf("********************************\n");

Subytes (estate); //Última ronda

Shiftrounds (estate);

AddRoundKey(estate,W,v); //Texto encriptado

Printf("********************************\n");

Printf("* texto encriptado *\n");

Printf("********************************\n")

Donde la función Datos_Inicales lo que hace es inicializar los datos necesarios para la

encripción como: matriz de estado, clave inicial, los datos correspondientes a la tabla S-

Box y datos de la matriz R_con.

Algo importante para destacar es que la clave no se genera cada ronda del algoritmo, sino

que se calcula toda al comienzo del algoritmo en la función KeyExpansion (key,W),

función que recibe como parámetro la clave inicial y el arreglo W, donde se van a guardar

todas las once claves para calcular la encripción de 128 bits.

41

Antes de iniciar las rondas del algoritmo, la matriz de estado sufre la primera

transformación (X-OR) con la clave, la función AddRoundKey(estate,W,v) se encarga de

realizar esta operación.

Al iniciar el “for” se realizan las nueve transformaciones del algoritmo, donde se escoge la

clave según la ronda en la que vaya operando, se realiza el corrimiento de columnas y las

multiplicaciones necesarias, pero la última ronda del algoritmo es diferente ya que esta

última sólo contiene tres transformaciones subytes (estate), shiftrounds (estate),

AddRoundKey(estate,W,v),

El funcionamiento del algoritmo se puede apreciar en la figura 5.2:

(a) (b)

El código utilizado en la des-encripción varía en el orden que se deben realizar las

funciones inversas, como se puede ver en el siguiente código:

Main ()

{

Datos_iniciales ();

Figura 5.2 Encripción AES-128 en C, (a) Texto de entrada (b) Encripción

42

KeyExpansion (key,W);

Inv_AddRoundKey(estate,W);

For(vuelta=10;vuelta>1;vuelta--)

{

Inv _ShiftRows(estate);

Inv _SubByte(estate);

Inv _AddRoundKey(estate,W);

Inv _MixColumns(estate, inv_matriz_mixcolumns);

}

Printf("********************************\n");

Printf(" Ronda Final \n");

Printf("********************************\n");

Inv _ShiftRows(estate);

Inv _SubByte(estate);

Inv _AddRoundKey(estate,W);

Printf("********************************\n");

Printf("* texto Desencriptado *\n");

Printf("********************************\n")

Durante el “for” las transformaciones a través de las nueve rondas del algoritmo de des-

encripción llevan un orden diferente, al igual que la ronda final, el funcionamiento se

puede apreciar en la figura 5.3.

43

(a) (b)

5.2. Implementación del algoritmo de encripción AES-128 en RTL

Para la implementación del algoritmo AES-128 en RTL, veremos cada uno de los módulos

del diagrama de bloques de la figura 4.5 en detalle.

5.2.1. Módulo AddroundKey

Este módulo es el que se encarga de hacer X-OR entre la matriz de estado y la clave

según la ronda en la que se encuentre el algoritmo, es por esto que en RTL este módulo

es un arreglo de compuertas X-OR, como el tamaño del bloque es de 128, la matriz de

estado es de 4x4 y la clave igual, el módulo AddroundKey se puede apreciar en la figura

5.4:

Figura 5.3 Des-encripción AES-128 en C, (a) Texto de entrada, (b) Des-encripción

44

AddroundKey

Figura 5.4 Módulo AddroundKey en RTL

En la figura 5.4 se puede ver el módulo AddroundKey, donde D hace referencia a la

entrada de los datos a encriptar y K es la clave que se va utilizar para el cálculo de la X-

OR, como el bloque de entrada es de 128, son 16 entradas cada una de 1 byte tanto para

datos y clave, las salidas del módulo son llamadas “OutR” que son las entradas módulo

ByteSub.

5.2.2. Módulo ByteSub

El módulo ByteSub es el acceso a una memoria ROM, donde se encuentran almacenados

los datos de la tabla S-Box, en esta transformación el dato que sale del módulo

AddroundKey por una de sus interfaces “OutR” es la dirección a la que se va a acceder en

la memoria.

Como la salida del módulo AddroundKey es de 16 Bytes, que a su vez es la entrada del

módulo ByteSub, se necesitan dieciséis memorias ROM para poder realizar la

transformación completa de los datos, la implementación para este trabajo de

investigación fue de unir estos 16 bloques de memoria en uno sólo con 16 entradas y 16

salidas como se puede apreciar en la figura 5.5:

45

Figura 5.5 Módulo ByteSub

En la figura 5.5 se pueden ver las 16 entradas del módulo, pero se puede apreciar que

las entradas al módulo Bytesub no se encuentran en orden, esto tiene que ver con la

transformación ShftRows que se explica en el siguiente apartado.

5.2.3. Módulo ShiftRows

Este módulo es el que se encarga de realizar el corrimiento de las filas, este está

determinado en la tabla 2.1, como este corrimiento no varía a través de las rondas, la

transformación puede ser traducida únicamente a conexiones físicas como se aprecian en

las entradas de la figura 5.5, donde lo que se hace es entregarle a la transformación

ByteSub las filas ya rotadas tal como lo entregaría el módulo ShiftRows.

La ventaja fundamental de realizar esta implementación es que no se usan ciclos de reloj,

para la implementación del corrimiento de las filas, y el circuito se convierte únicamente

en conexiones.

5.2.4. Módulo MixColumns

La transformación MixColumns es la multiplicación de dos matrices; la matriz de entrada

al módulo y la matriz de multiplicación MixColumns que se puede apreciar en la figura

2.14, la matriz de entrada es la salida del módulo ByteSub.

46

Algo importante para aclarar es que la multiplicación que se va a realizar es la de 2

matrices, es por esto que hay que acomodar los datos para poder realizarla, en la figura

5.6 se puede apreciar cómo se organizan los datos para realizar la multiplicación:

Figura 5.6 Transformación MixColumns

Las dos matrices a multiplicar se pueden analizar mejor en la figura 5.7:

(a) (b)

Figura 5.7 Matrices (a) Matriz de estado (b) Matriz MixColumns

47

La multiplicación para obtener la primera columna seria de la siguiente manera:

( ) ( ) ( ) ( )

( ) ( ) ( ) ( )

( ) ( ) ( ) ( )

( ) ( ) ( ) ( )

Esta es únicamente la multiplicación para la columna 0, este mismo procedimiento hay

que realizarlo para la columna 1, 2 y 3 respectivamente.

Los cables negros, rojos azules y amarillos en la figura 5.6 lo único que hacen es llevar

los cuatro datos de la matriz de estado a la multiplicación que se va a realizar en cada uno

de los módulos comb1, comb2, comb3, comb4.

En cada uno de los sub-módulos van a estar los valores a multiplicar de la matriz de

Mixcolumns.

Como se puede apreciar en la figura 5.8 para cada uno de los sub-módulos se agrega una

fila de la matriz MixColumns para realizar la multiplicación.

5.2.4.1. Sub-Módulo Comb1

Este módulo se encarga de la multiplicación de los datos que entran junto a los datos de

la matriz MixColumns que para este caso sería 02, 03, 01 y 01, algo importante para

recordar en esta transformación es que las operaciones están basadas sobre el campo

GF ( ), es por esto que si el resultado de una multiplicación no puede ser mayor a 7 bits.

Para resolver el problema de desbordamiento del resultado, se implementó el algoritmo X-

TIME descrito en el apartado 2.2.5, en el cual se muestra el código en C de la función,

esta función se encarga de normalizar los datos al campo GF ( ), para esto el resultado

Comb1

Comb2

Comb3

Comb4

Figura 5.8 Matriz MixColumns

48

de la multiplicación le hace X-OR con 0x1B ( ( )

=000100011011) que es el polinomio irreducible en el campo GF ( ).

La implementación en RTL de este algoritmo la vemos a continuación en la figura 5.9:

Figura 5.9 Diagrama función X-TIME

Así vemos en la figura 5.9 la implementación de la función X-TIME, el funcionamiento se

puede describir en los siguientes pasos:

1. A la entrada del multiplexor esta data [7] que es el bit más significativo del dato a

multiplicar, si este bit se encuentra en ‘1’ dejara pasar la entrada s2 de lo contrario

conmutara para permitir el paso de s1.

2. Si el bit 7 se encuentra en 1 quiere decir que la multiplicación por dos o por tres,

necesitarán ser normalizados, así que se realiza la multiplicación por dos haciendo

un corrimiento de bits y luego se normaliza con la X-OR 0x1B.

3. En caso de que el bit 7 de los datos de entrada este en cero, únicamente se

realiza la multiplicación por dos realizando el corrimiento de bits.

La salida de la función X-TIME siempre arrojará el resultado multiplicado por dos, pero

para la implementación del algoritmo hay que realizar multiplicaciones por tres, este tipo

de operaciones en hardware son muy costosas en cuanto a número de compuertas

potencia y desempeño.

La multiplicación puede ser expresada de la siguiente manera:

Reescribiendo el número 03 de la siguiente manera obtenemos:

49

En binario

Entonces la multiplicación podría ser reemplazada de la siguiente manera:

Resolviendo en binario:

Lo que quiere decir es que cualquier multiplicación puede ser representada por

multiplicaciones por dos, junto con la función X-OR, basándose en que el bloque X-TIME

de la figura 5.9, realiza la multiplicación y se implementó el siguiente diseño para el sub-

módulo comb1:

Figura 5.10 Sub-módulo Comb1

En la figura 5.10 se aprecia en detalle cómo la primera entrada es multiplicada por dos, la

segunda entrada es multiplicada por tres y en las dos últimas la multiplicación es por uno.


La diferencia entre los sub-módulos es el valor por el cual hay que multiplicar los datos

que ingresan, para este caso los datos según la figura 5.8 son [01, 02, 03 ,01], la

implementación en hardware la veremos en la figura 5.11:

50


En la figura 5.11 se puede apreciar cómo en la primera entrada la multiplicación es por

uno, en la segunda entrada la multiplicación es por dos, en la tercera entrada es por tres y

en la última entrada la multiplicación es por uno.


Para este caso los datos según la figura 5.8 son [01, 01, 02 ,03] para multiplicar, la

implementación en hardware se detalla en la figura 5.12.


En la figura 5.12 se muestra cómo la primera entrada es multiplicada por uno, la segunda

también es multiplicada por uno, la tercera entrada es multiplicada por dos y la última

entrada es multiplicada por tres.

51


Para este caso los datos, según la figura 5.8 son [03, 01, 01 ,02], para multiplicar, la

implementación en hardware se puede apreciar en la figura 5.13.

Figura 5.13 Sub-módulo C apreciar comb4

La figura 5.13 demuestra cómo la primera entrada es multiplicada por tres, la segunda

entrada es multiplicada por uno, la tercera entrada es multiplicada nuevamente por uno y

la última entrada es multiplicada por dos.

5.2.5. Módulo KeyExpansion

El módulo de la expansión de la clave es el encargado de generar las claves partiendo de

la clave ingresada al comienzo, cada ronda es calculada con una nueva clave que es

tomada de este módulo.

El algoritmo que describe la función del módulo KeyExpansion esta descrito en el

apartado 2.3.1.6.2, el problema fundamental era convertir este código a RTL, la función

KeyExpansion se divide en dos partes, el algoritmo ejecuta una función cuando la

columna a analizar es múltiplo de 4 y otra cuando no lo es.

Cada columna analizada genera una nueva columna para una nueva clave, lo que quiere

decir que cuatro columnas analizadas generan una nueva clave de cuatro columnas, en

ese orden de ideas cada vez que hay una ronda debe estar lista una calve para poder

realizar la transformación respectiva.

En la figura 5.14 detallamos el diagrama de la implementación de la transformación

KeyExpansion:

52

Figura 5.14 Módulo KeyExpansion

En la figura 5.14 se puede apreciar el módulo KeyExpansion donde la entrada del bloque

es la columna a expandir, en la primera ronda vendría siendo la Columna 3, como la

cuarta columna es múltiplo de 4 por eso entra al módulo M4 y la salida de este módulo es

la primera columna de la nueva clave y también la entrada del siguiente módulo NM4.

5.2.5.1. Sub-Módulo M4

El módulo M4 es el encargado de generar una nueva columna partiendo de las columnas

que son múltiplos de 4, únicamente estas columnas son las que entran a este sub-

módulo, la implementación de este sub-módulo es posible analizarla en la figura 5.15:

Figura 5.15 Sub- Módulo M4

53

En la figura 5.15 se puede entonces apreciar la implementación del sub-módulo M4 que

se divide en cuatro transformaciones pequeñas que se describen a continuación:

1. RotByte: Esta transformación lo que hace es una rotación de los 4 bytes que

entran al módulo para entregárselos a la siguiente transformación ByteSub, tal

como se puede apreciar en la figura 5.15.

2. ByteSub: Esta transformación al igual que en la implementación de AES, realiza

una sustitución de los bytes a la entrada por datos de la S-BOX que se encuentran

guardados en una ROM, como son 4 bytes esta ROM tiene cuatro entradas y

cuatro salidas.

3. R_con: la transformación R_con se encarga de realizar una sustitución del primer

byte que arroja como salida la transformación ByteSub, al final la transformación

R_con es una memoria ROM a la que se accede para reemplazar o sustituir un

dato.

4. La salida de las transformaciones anteriores pasan a realizar una X-OR con la

columna actual menos 4, es decir, si estamos haciendo la expansión de la

columna 4 la X-OR será el resultado de las transformaciones internas M4 con la

columna 1.

5.2.5.2. Sub-Módulo NM4

El Sub-módulo NM4 es la siguiente etapa del módulo M4 y se replica tres veces, este

módulo es el encargado de analizar las columnas de la clave a expandir que no son

múltiplos de 4, su implementación se demuestra en la figura 5.16:

Figura 5.16 Sub-Módulo NM4

54

El módulo de la figura 5.16 realiza la X-OR de los datos entregados por el sub-módulo M4

con la cuarta columna anterior la que se esté expandiendo y que se encuentran

guardadas en el arreglo W.

En la expansión de la clave hay un sub-módulo M4 y tres módulos NM4, estos últimos tres

son exactamente iguales, el resultado de cada uno es una columna de la clave, por esto

los 4 sub-módulos generan una clave completa.

5.3. Implementación del algoritmo de des-encripción AES-128 en

RTL

La diferencia fundamental es el orden en el cual se hace la función para realizar la des-

encripción:

1. Inv_AddroundKey

2. InvShiftRound

3. Inv_SubByte

4. Inv_AddroundKey

5. Inv_MixColumns

6. Inv_ShiftRounds

7. Inv_SubByte

8. Inv_AddroundKey

La implementación del módulo de des-encripción AES-128 tiene igual número de rondas

que el módulo de encripción 10, donde la última ronda del módulo de des-encripción es

diferente a las primeras nueve, el diagrama de bloques del algoritmo se plasma en la

figura 5.17

Figura 5.17 Diagrama de bloques Des-Encripción Aes128

En la figura 5.17 vemos entonces el diagrama de bloques de la encripción, la cual nos

muestra 10 bloques, de los cuales el único diferente es el último al igual que el módulo de

encripción.

Ronda Final

Rondas

Intermedias

55

En la figura 5.18 se puede apreciar la implementación del sub-módulo R1

Figura 5.18 Módulo R des-encripción Aes 128

En la figura 5.18 se muestra el sub-módulo R que consta de cuatro transformaciones:

Inv_ByteSub, Inv_AddroundKey, Inv_MixColumns, y contiene un módulo de expansión de

la clave para la des-encripción en cada ronda.

En la entrada del módulo en la figura 5.18 hay un sub-módulo Inv_AddrounKey, que antes

de empezar con el algoritmo hace la X-OR de los datos con la clave inicial, esto es sólo

para el comienzo del algoritmo.

Es importante aclarar que como AES es un algoritmo simétrico, la clave de encripción es

la misma para la des-encripción.

En la figura 5.19 se puede apreciar el sub-módulo U que hace parte de la última ronda de

la des-encripción:

Figura 5.19 Módulo U des-encripción Aes 128

5.3.1. Módulo Inv_AddroundKey

56

Este módulo al igual que en la ronda de encripción, se trata de compuertas X-OR entre la

clave y el dato que se esté procesando según la ronda donde se encuentre el algoritmo.

5.3.2. Módulo Inv_ByteSub

El módulo Inv_ByteSub al igual que en la encripción, se encarga de realizar una

sustitución del dato que le ingresa a las memorias ROM, la única diferencia entre la

encripción y la des-encripción, es que la tabla que se encuentra guardada en la ROM, es

la tabla S-BOX invertida que se puede apreciar en la Figura 2.7.

5.3.3. Módulo Inv_ShiftRows

El módulo Inv_ShiftRows al igual que en el módulo ShiftRows, se debe realizar las

rotaciones sobre las filas que le indican la tabla 2.1, pero en este caso la rotación debe

hacerse hacia la izquierda.

En esta implementación se realizó la rotación a la entrada de la función ByteSub, igual

que se hizo en la encripción como se puede ver en la figura 5.5

5.3.4. Módulo Inv_Mixcolumns

El transporte de datos para realizar la función Inv_Mixcolumns es igual a la de la función

Mixcolumns que se encuentra en la figura 5.5, la diferencia está en el valor por el cual se

realizan las multiplicaciones dentro de los sub-módulos.

5.3.4.1. Sub-Módulo Inv_Comb1

Las multiplicaciones que se realizan en el módulo Inv_Comb1 según la matriz

Inv_MixColumns son [0E, 0B, 0D, 09], las multiplicaciones se pueden apreciar en la figura

5.20:

Figura 5.20 Sub-Módulo Inv_Comb1

57


El módulo Inv_Comb2 realiza las siguientes multiplicaciones según la matriz

Inv_MixColumns [09, 0E, 0B, 0D], las multiplicaciones se pueden ver en la figura 5.21:




Inv_MixColumns [0D, 09, 0E, 0B], las multiplicaciones se pueden apreciar en la figura

5.22:


58



Inv_MixColumns [0B, 0D, 09, 0E], las multiplicaciones se muestran en la figura 5.23:


5.4. Testbench

La finalidad de un testbench es de verificar el correcto funcionamiento de un diseño,

dependiendo de la instancia del diseño en que nos encontremos el testbench puede

hacerse más complejo o más sencillo, ya que simplemente se pueden generar los

estímulos para verificar conexiones del diseño, o generar estímulos aleatorios e ir

revisando las salidas de los puertos al mismo tiempo.

Para la primera parte de comprobación del funcionamiento del diseño, se implementó un

testbench básico, que se puede apreciar su diagrama en la figura 5.24:

(a) Testbench Encripción (b) Testbench Des-Encripción

Figura 5.24 Módulos Testbench

59

En la figura 5.24 se puede apreciar el Testbench para cada módulo, algo importante para

resaltar es que en el Testbench las salidas son las entradas del módulo AES y las salidas

del módulo AES son las entradas del Testbench, esto con el fin de que las señales o

estímulos que genere el Testbench entren al módulo AES y que las salidas en respuesta

a ese estímulo puedan ser verificadas por el mismo Testbench.

El primer test que se implementó tenía como objetivo estimular el circuito para ver que las

conexiones entre los sub-módulos estuvieran funcionando y mirar la funcionalidad de los

módulos de una manera visual, la simulación del módulo de encripción se puede ver en la

figura 5.25:

En la figura 5.25 se encuentra la simulación del módulo de encripción AES, como todo el

diseño es combinacional, la respuesta del módulo es inmediata, tal como se puede ver en

la figura 5.25, los estímulos ingresados fueron los mismos ingresados en la

implementación en C.

(a) (b) (c)

Figura 5.25 Simulación Aes Encripción

Figura 5.26(a) Datos de entrada (b) Clave Inicial (c) Datos Encriptados

60

Los resultados de la Encripción en RTL son iguales a los resultados obtenidos en el

algoritmo en C, figura 5.25 y figura 5.2.

La simulación del test básico del módulo de des-encripción se puede apreciar en la figura

5.27:

Figura 5.27 Simulación Aes Des-Encripción

Los datos de entrada a esta simulación son la salida del módulo en encripción y la salida

de este módulo es igual a los datos iniciales.

Conectando los dos módulos y simulándolos con el test básico obtenemos la figura 5.28:

Figura 5.28 Simulación Aes-128 Encripción y des-Encripción

En la figura 5.28 hallamos la salida encriptada y des-encriptada donde los datos iniciales

son iguales a la salida des-encriptada.

La siguiente prueba fue con un testbench estructurado, del cual se puede apreciar su

diagrama de bloques en la figura 5.29

61

La estructura del testbench se divide en varios módulos que cumplen determinada función

dentro del proceso de verificación, la idea de este testbench es verificar la salida del

módulo para ver que todos los paquetes que se encriptan están correctos.

El diseño del testbench utilizado fue:

Módulo Test: genera las señales aleatorias para excitar el diseño o DUT

Módulo Driver: Es la clase donde se generan los objetos del TestBench

Módulo Tb: es el encargado de las interfaces del TestBench

Módulo Top: es el encargado de la conexión del DUT con el TestBench

Módulo Checker: Revisa la salida del testbench vs. el diseño o DUT

En la figura 5.30 se puede apreciar la simulación de la encripción con un testbench

generando señales aleatorias

Figura 5.30 Testbench Aleatorio Encripción

Es la figura 5.30 se puede apreciar que el TestBench genera las señales aleatoriamente,

el último paso del Testbench es verificar que la salida del módulo se encuentra

encriptando de forma correcta.

Figura 5.29 Testbench estructurado

62

5.4.1. Verificación

Para verificar el diseño se implementó dentro del Testbench el módulo en C que se diseñó

al comienzo del trabajo de investigación, como el Testbench no es sintetizable, la

implementación de códigos de alto nivel para verificar RTL es posible.

Para poder integrar el código en C al Testbench fue necesario hacer uso de DPI-C “Direct

Programming Interface” que es la interface de comunicación entre el Testbench y las

funciones en C, la manera de importar las funciones de C es la siguiente:

Import "DPI-C" function void import_func();

Esta función permite ejecutar funciones en C desde un Testbench, pero los valores que

genera el código en C hay que enviarlos al Testbench para la verificación del RTL, para

esto se utiliza la siguiente función:

Export "DPI-C" function export_func;

El Testbench se va a encargar de generar los estímulos para el DUT o el algoritmo de

encripción y también para el código en C, para que luego el mismo Testbench se

encargue de comparar los dos resultados y verificar el correcto funcionamiento del diseño.

Figura 5.31 Testbench Algoritmo Encripción

En la figura 5.31 está la estructura del Testbench donde el generador de estímulos

alimenta al algoritmo en C y al RTL, estos estímulos pueden ser de orden aleatorios o

también pueden ser de lectura de archivos u otros.

Para la primera parte de verificación se implementó un Testbench que generará estímulos

aleatorios al algoritmo de encripción en RTL y en C como se puede apreciar en la figura

5.32:

63

Figura 5.32 Testbench Aleatorio módulo Encripción

Así, la figura 5.32 demuestra que hay una señal nueva que se llama

AES_encrypted_from_C, esta señal es la salida del algoritmo de encripción en C, se

puede apreciar en la figura que la salida del algoritmo es la misma que la salida del

módulo en RTL AES_out_Enrypt.

Figura 5.33 Testbench aleatorio módulo des-encripción

La figura 5.33 permite apreciar el Testbench generando estímulos aleatorios del módulo

de des-encripción.

Para estar seguros del funcionamiento conectado los dos módulos encripción y des-

encripción en serie y poniendo a funcionar un test aleatorio sus resultado se puede ver

detallado en la figura 5.33.

64

Figura 5.34 Testbench aleatorio de los módulos en serie.

Como se puede apreciar en la figura 5.34 los datos que entran al módulo de encripción

son exactamente los mismos que salen por el módulo de des-encripción.

La prueba final del testbench para la verificación de los circuitos fue de la encripción y

des-encripción de dos archivos de los cuales uno fue una imagen de tamaño de 20KB y el

otro un archivo de texto de 28 KB, estos dos archivos se pueden apreciar en la figura

5.35.

(a) (b)

Figura 5.35 Archivos de prueba (a) Imagen (b) Texto

65

La intención al procesar un texto y una imagen, era estimular el circuito no solo con texto

sino con datos diferentes para ver su funcionamiento y comportamiento en potencia y

área, resultados que se ven reflejados el capítulo de análisis de resultados.

El testbench se encarga de llamar a la función en C que lee el archivo de entrada

Import "DPI" function void leer_archivo();

Esta funcion se encarga de leer el archivo y de enviar los datos al testbench de manera

que el circuito pueda entenderlos para encriptarlos o des-encriptarlos dependiendo el

caso.

El archivo en C se encarga de guardar los datos de entrada en una matriz de n x 16

enviando al circuito los datos síncronos al reloj, para la encripción del archivo:

Figura 5.36 Testbench de lectura de imagen

Como se aprecia en la figura 5.36 las salidas AES_out_Encrypt y AES_encryted_from_C

son iguales, pero la forma de garantizar que realmente sean iguales es analizándolas bit

por bit, la estructura del test para verificar la encripción se puede ver en el siguiente

código:

leer_archivo(); //ingresa el archivo a encriptar

$display("SV: tamano %h",tamano); //tamaño del archivo

for(i=0;i<tamano;i=i++)

begin

#1 envio_datos(i);

test_Aes_encriptor_completo(); // entrega la clave

AES_Encrypt(estateSV,keySV); //Envialos datos a C

check; //compara los datos de C y SV

Este código lee el archivo a encriptar y dependiendo al número de datos realiza un for,

donde le va entregando los datos al circuito y los va revisando con la función check que

se puede ver a continuación:

66

Task check;

int l;

for(l=0;l<16;l++)

begin

if(Aes_encrypted_from_C[l]!=1'bx)

begin

$fwriteh(fileC,Aes_encrypted_from_C[l]); //salida del modulo en C

end

if(AES_out_Encrypt[l]!=1'bx)

begin

$fwriteh(file,AES_out_Encrypt[l]); //salida del RTL

end

@(posedge clk);

if(Aes_encrypted_from_C!=AES_out_Encrypt)

begin

error_count=error_count+1;

end

end

endtask

El código anterior es la tarea que se encarga de escribir los datos que genera el código en C y el RTL en dos archivos .txt, también en la última parte compara las dos salidas de los módulos y en caso de ser diferentes suma un contador para notificarlo al final, en caso de que los archivos sean iguales, el test notifica que la encripción fue exitosa.

(a) (b)

Figura 5.37 (a) Archivo generado RTL (b) Archivo generado por C

67

La figura 5.37 permite apreciar los archivos generados por el RTL y el módulo de C, que

deben ser iguales para que el test sea exitoso.

5.5. Líneas de Pipe (optimización)

Hasta el momento los módulos trabajan de forma concurrente y no tienen líneas de pipes,

para poder agregar estas líneas de manera eficiente, se implementó el módulo

“Adaptative Retime” de synopsys, que lo que busca es agregar las líneas de pipe donde lo

necesite el circuito para poder ocupar la menor área posible manejando bajos niveles de

potencia y cumpliendo las metas de desempeño.

Esta es una de las técnicas de optimización utilizadas para poder mitigar el impacto que el

área puede causar sobre el circuito. La técnica de optimización adaptative retime mueve

los registros y los latches para mejorar los caminos críticos en el diseño, en uno de

grandes conexiones y de gran carga combinacional.

Cuando se está describiendo circuitos digitales antes de la síntesis del mismo, no es fácil

encontrar cual es el lugar óptimo para poder colocar las líneas de pipes y codificarlas en

HDL, con esta función el sintetizador Design Compiler se encarga de ubicar las líneas de

pipes en el diseño para que pueda así cumplir con las metas de tiempo mejorando los

caminos críticos, analizando en qué lugar podrían mostrar un mejor desempeño,

realizando la implementación de esta técnica, estamos mejorando desempeño y potencia

a la vez, una muestra de cómo funciona esta técnica se puede comprobar en la figura

5.38.

Figura 5.38 Técnica adaptative retime

En esta figura 5.38 se ve cómo esta técnica detecta en qué parte del circuito se encuentra

concentrada más carga combinacional y corre los pipes para mejorar tiempo en el diseño

afectando directamente área y potencia.

68

La potencia se ve afectada positivamente ya que no todo el circuito se encuentra

trabajando al tiempo entonces la potencia que disipará el circuito será menor.

Para poder aplicar la técnica adaptative retime se creó un Script de síntesis del circuito,

esto con el fin de convertir el código que se implementó de módulos a compuertas.

5.6. Síntesis

La síntesis del diseño se realiza mediante las herramientas de synopsys “Design

Compiler” el cual se encarga de hacer la conversión de código a compuertas lógicas y nos

dice si realmente nuestro diseño puede ser llevado a un circuito integrado. Esta

herramienta dependiendo de los parámetros que se le entreguen se encarga de realizar

las optimizaciones necesarias en cuanto a área desempeño y potencia.

Para poder poner a correr esta herramienta es útil la realización de un script, el cual se va

encargar de darle los comandos de configuración que se necesitan para la síntesis del

diseño.

Lo primero que hay que hacer para realizar la síntesis es entregarle al Design Compiler

las librerías que va a utilizar en el proceso:

Link_library / saed90nm_typ.db

Esta librería contiene la información sobre las celdas del proceso.

Target_library / saed90nm_typ.db

El target library es el archivo que contiene las celdas lógicas que se van a utilizar durante

la síntesis.

Symbol_library /saed90nm.sdb

La librería Symbol contiene los símbolos de las compuertas, para poder generar los

símbolos esquemáticos del diseño cuando se requieran.

La librería del proceso es de 90 nanómetros, esto quiere decir que el tamaño de los

transistores de 90 nm, al igual que el trabajo de investigación con el cual se está

realizando la comparación.

Analyze -library WORK -format sverilog

Este comando nos permite revisar la sintaxis de cada archivo que se va a compilar.

Elaborate -architecture verilog -library WORK

Elaboro el módulo principal.

Link

69

Enlazo todos los módulos.

Check_design

Reviso el diseño.

Create_clock clk -name CLK -period

Se le entrega el reloj para la síntesis del circuito.

Set_max_area

Le entrego la meta de área que quiero para el diseño.

Compile

Gui_start

Arranco la gui del Design Compiler.

Los script son archivos que permiten entregarles los comandos a las herramientas de

síntesis, estos archivos tienen la extensión .tcl.

En la figura 5.39 se puede apreciar la gui del design compiler con el módulo de

encripción:

Figura 5.39 GUI Design compiler módulo encripción.

Para el uso de la función adaptative retime es necesario generar las líneas de pipes y

hacer uso del siguiente código:

Set_optimizer_register

70

Compile_ultra –retime

5.7. Plan de pruebas

Para esta parte se generaron las siguientes pruebas:

Implementar varias líneas de pipes en el diseño y aplicar el módulo de

optimización adaptative retime de synopsys a una frecuencia de operación de 20

ns y 30 ns.

Reportar las optimizaciones de potencia estática y área para los diseños

optimizados, analizando las mejoras obtenidas después de la optimización.

Crear los archivos SAIF que contienen la información de switcheo del circuito,

tomadas de la encripción y des-encripción de la imagen y texto, para generar los

reportes de potencia dinámica del circuito con el POWER COMPILER de

synopsys.

5.7.1. Implementación Adaptative Retiming

Para la implementación del módulo Adaptative Retiming, primero hay que generar los

bloques de pipes dentro del encriptor y des-encriptor para que sean optimizados por esta

herramienta, el código puesto en la salida del módulo encriptor y des-encriptor para crear

el bloque de pipes fue:

logic [7:0] flops0 [N];



always @(posedge clk)

begin

flops0<=AES_out_aux_flop;

flops1<=flops0;

flops2<=flops1;

AES_out<=flops1;

End

La salida del módulo se ve afectada de esta manera con un retraso de cuatro ciclos de

reloj mientras pasa por los flops puestos en el código, como se puede ver en la simulación

de la figura 5.40.

71

Figura 5.40 Implementación de un pipe de 4 stages

De forma gráfica en el módulo, se aprecia en la figura 5.41.

Figura 5.41 implementación de un pipe de 4 stages

Después de tener las líneas de pipes a las salidas de los módulos se reporta potencia

estática que será comparada con la salida después de la optimización adaptative retiming.

El comando para en el dc_shell para los reportes son:

dc_shell: report_power // reporta potencia

La herramienta Design_vision nos reporta los resultados de potencia de la siguiente

manera:

Global Operating Voltage = 1.2

Power-specific unit information:

Voltage Units = 1V

Capacitance Units = 1.000000ff

Time Units = 1ns

Dynamic Power Units = 1uW (derived from V,C,T units)

Leakage Power Units = 1pW

72

Cell Internal Power = 6.3160 mW (63%)

Net Switching Power = 3.6750 mW (37%)

---------

Total Dynamic Power = 9.9910 mW (100%)

Cell Leakage Power = 2.5285 mW

Donde encontramos Total Dynamic Power hace referencia a la potencia estática del RTL,

ya que se está reportando la potencia sobre el circuito sin ninguna actividad de switcheo.

Después de obtener los resultados, se activa el módulo de optimización adaptative

retiming donde a los flops los renombra como DFFX y los reubica; para poder saber la

ubicación de los flops, se mira el archivo netlist que es el archivo que muestra a nivel de

compuertas todo el diseño: como se aprecia en la figura 5.42.

(a) (b)

La potencia se reporta de la misma manera que se hizo previamente:

report_area

Figura 5.42 movimiento de pipes (a) Netlist (b) Modo gráfico

73

5.7.2. Archivos SAIF (switching activity information)

Los archivos SAIF son generados en la simulación, contienen el número de toggles o

cambios de las señales durante el tiempo que dure simulando, como el cálculo de la

potencia dinámica se debe realizar cuando el circuito se encuentra trabajando, estos

archivos son usados para reportar la potencia dinámica.

El SAIF file se puede generar de dos formas:

Convirtiendo el archivo VCD que se genera desde el testbench.

Monitoreando los toggles de las señales con las instrucciones $toggle_start,

$toggle_stop.

(SAIFILE

(SAIFVERSION "2.0")

(DIRECTION "backward")

(DESIGN )

(DATE "Sun Oct 20 03:26:28 2013")

(VENDOR "Synopsys, Inc")

(PROGRAM_NAME "vcd2saif")

(VERSION "D-2010.03-ICC-SP5")

(DIVIDER / )

(TIMESCALE 1 ns)

(DURATION 20198)

(INSTANCE tb_Aes_encriptor_completo_top

(NET

(clk

(T0 10099) (T1 10099) (TX 0)

(TC 20198) (IG 0)

)

)

(INSTANCE Aes_Encriptor_Completo

(NET

(clk

(T0 10099) (T1 10099) (TX 0)

(TC 20198) (IG 0)

)

)

(INSTANCE GenAddroundKey

(INSTANCE AddroundKey\[0\]\.AddroundKey

(NET

(Data_in\[0\]

(T0 9948) (T1 10236) (TX 14)

(TC 814) (IG 0)

74

)

El código anterior es una muestra de una parte de un archivo SAIF donde:

T0: número de toggles

T1: tiempo en ´1´

T0: tiempo en ´0´

Tx: tiempo en ´x´

Dependiendo el número de señales el archivo es más grande y genera la información de

toggles para cada una de las señales en el diseño.

Estos archivos son entregados al circuito en el design visión para realizar el cálculo de la

potencia dinámica, de la siguiente manera:

dc_shell: read_saif –input encriptor.saif –instance_name tb_encriptor_top/encriptor

Este comando le entrega al design visión la información de toggles del circuito, para

realizar el cálculo de la potencia dinámica, encriptor.saif se hace referencia al nombre del

archivo.saif. y la parte de –instance_name hace referencia a la instancia a analizar dentro

del archivo.saif.

Después de generar los archivos, se reporta la potencia de la misma manera que se hizo

para la potencia estática.

report_power

Pero esta vez los resultados hacen referencia a la potencia dinámica del circuito.

75

Capítulo 6

6. PROBLEMAS

Durante la implementación del módulo de optimización adaptative retiming el consumo de

memoria es muy grande, cuando se intentó implementar el modulo para 8 líneas de pipes

el servidor donde están instaladas las herramientas de synopsys se desbordaba en

memoria y no era posible realizar el proceso completo.

Para poder realizar el análisis del circuito con una línea de 8 pipes a una frecuencia de

operación de 50 MHZ fue necesario dividir el circuito en 2 partes e implementar el módulo

de optimización

La forma en que se dividió el circuito para los análisis de 8 pipes fue:

Como el módulo de encripción y descripción tienen 10 rondas se analizaron las 5

primeras rondas:

Figura 6.1 Circuito AES parte 1

Para esta parte se pusieron 4 líneas de pipes y en la otra mitad que se puede apreciar en

la figura 6.2 se pusieron las otras 4 líneas de pipes para completar las 8 líneas de pipes

Figura 6.2 Circuito AES parte 2

De esta manera se lograron obtener los resultados de 8 líneas de pipes a 20 ns, para la

parte de descripción se hizo de la misma manera; también se hizo un análisis a 30 ns

implementando esta misma metodología.

Un inconveniente grande es que las simulaciones de multiplicaron y obtener los datos fue

bastante tedioso, para un trabajo futuro se podría analizar cuál sería el máximo líneas de

pipes hasta donde el circuito obtiene los mejores resultados.

Para realizar este tipo de estudios, se requiere de un servidor con más memoria y un

procesador con un mejor desempeño ya que las herramientas demandan alto grado de

recursos al servidor donde se encuentran instaladas.

76

Las síntesis que se tuvieron que dividir para poder realizar el análisis de potencia en la

encripción se puede apreciar en la taba 6.1

Encripción pipes pipes pipes pipes

20ns 8 -- -- --

30ns 8 6 4 2

Tabla 6-1 división módulo encripción

Para la parte de des-encripción la división se puede apreciar en la tabla6.2

Des Encripción pipes pipes pipes

20ns 4 -- --

30ns 4 3 2

Tabla 6-2 división módulo des-encripción

77

Capítulo 7

7. ANÁLISIS DE RESULTADOS

Como se mencionó en el capítulo 5 apartado 5.7 se realizó un análisis del

comportamiento del circuito a 20ns y a 30ns los resultados se pueden apreciar en los

siguientes apartados.

7.1. Análisis de área

El análisis que se realizó sobre el circuito tiene 2 fases tanto para la encripción y des-

encripción, la primera parte los resultados fueron obtenidos sin aplicar el módulo de

optimización y luego los resultados después de la optimización.

7.1.1. Módulo de Encripción, reportes de Área a 20 ns.

.

Figura 7.1 Gráficas de área del Encriptor a 20ns

1.017.023,78

992.747,75 996.493,35

1.000.203,52

1046003,39 1.017.023,78

1.089.662,09

1.023.125,09

994.653,48

924036,6

900.000,00

920.000,00

940.000,00

960.000,00

980.000,00

1.000.000,00

1.020.000,00

1.040.000,00

1.060.000,00

1.080.000,00

1.100.000,00

0 2 4 6 8 10

Area microns

Pipes

Area Encriptor a 20 ns

Sin Adaptative

Retime

Con Adaptative

Retime

78

En la figura 7.1 se puede apreciar que con la implementación de líneas de pipes

únicamente en la salida (grafica roja) descrita en el apartado 5.7.1, el área baja

para algunas implementaciones, así mismo también se pueden ver los resultados

en azul de la implementación después de la optimización con el módulo adaptative

retime, claramente se ve que con cada línea de pipes el área mejora.

7.1.2. Módulo de Encripción, reportes de Área a 30 ns.

Figura 7.2 Gráficas de área del Encriptor a 30ns

En la figura 7.2 se puede ver que los resultados obtenidos esta vez a 30 ns donde se ve

en rojo los resultados obtenidos sin la optimización, y en azul los resultados de la

optimización de las líneas de pipes, donde claramente se ve que también hay una mejora

sobre el área en el circuito.

7.1.3. Módulo de des-encripción, reportes de Área a 20 ns.

Ahora se mostrarán los resultados obtenidos para el módulo de des-encripción, los

análisis al igual que en la encripción se hicieron para 20ns y 30ns

1.017.023,78

993.113,84

1.005.579,74

1.020.989,00

1.036.829,65

1.017.023,78

987.914,33

1.002.201,00 1.006.201,82

1.031.930,22

980.000,00

990.000,00

1.000.000,00

1.010.000,00

1.020.000,00

1.030.000,00

1.040.000,00

0 2 4 6 8 10

Area microns

Pipes

Area Encriptor 30ns

Sin Adaptative

Retime

Con Adaptative

Retime

79

Figura 7.3 Gráficas de área del des Encriptor a 20ns

En la figura 7.3 se encuentra el comportamiento del módulo de des-encripción sin el

módulo de optimización (azul), y el comportamiento del área luego de utilizar el módulo

adaptative retime (rojo) donde se aprecia que el área es mucho mayor que la del

encriptor, ya que este módulo cuenta con el sub-módulo de bytesub para generación de

las claves, y el sub-módulo Inv_ByteSub para la solución de cada una de las rondas del

módulo de des-encripción.

7.1.4. Módulo de des-encripción, reportes de Área a 30 ns.

Figura 7.4 Gráficas de área del Des-Encriptor a 30ns

1.028.926,361

1.068.710,487 1.072.328,203

1.076.157,758

1.028.926,361

1.184.213,838

1.148.938,250

1.179.716,036

1.020.000,000

1.040.000,000

1.060.000,000

1.080.000,000

1.100.000,000

1.120.000,000

1.140.000,000

1.160.000,000

1.180.000,000

1.200.000,000

0 1 2 3 4 5

Area microns

Pipes

Area Des-Encriptor a 20 ns

Sin Adaptative

Retime

Con Adaptative

Retime

1.028.926,361

1.285.794,540 1.293.255,120 1.300.715,680

1.028.926,361

1.320.723,820 1.333.222,960 1.337.566,900

0,000

200.000,000

400.000,000

600.000,000

800.000,000

1.000.000,000

1.200.000,000

1.400.000,000

1.600.000,000

0 1 2 3 4 5

Area microns

Pipes

Area Des-Encriptor 30 ns

Sin Adaptative

Retime

Con

Adaptative

Retime

80

En la figura 7.4 se puede ver el comportamiento del área a 30 en el módulo de des-

encripción tanto de la implementación con el módulo de optimización y sin él. Es

importante resaltar que el área sufre un aumento con el cambio de frecuencia de 20 a 30

ns para el módulo de des-encripción.

7.2. Análisis de potencia estática

Para la parte de análisis de potencia se analizó la potencia estática y dinámica disipada

del circuito, a 20ns y 30ns para el módulo de encripción y des-encripción, graficando cada

uno de sus resultados

7.2.1. Análisis de potencia estática módulo de encripción

20ns

Figura 7.5 Gráficas de la potencia estática del Encriptor a 20 ns

En la figura 7.5 se puede apreciar como se ve afectada la potencia favorablemente con la

implementación de líneas de pipes a la salida del circuito (línea roja), de pasar de 741mw

con 0 líneas de pipes hasta 33.08mw con 8 líneas de pipes, comprobando las ventajas de

implementar líneas de pipes en un circuito, pero la gran mejora se puede ver (línea azul)

cuando se implementa el módulo de optimización obteniendo resultados a 8 pipes de 20

mw,

741,8970

35,1603 35,1679 35,1864 33,0877

741,8970

22,6137 20,8930 18,9897

20,0700

-100,0000

0,0000

100,0000

200,0000

300,0000

400,0000

500,0000

600,0000

700,0000

800,0000

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Estática Encriptor a 20 ns

Sin Adaptative

Retime

Con Adaptative

Retime

81

Figura 7.6 Gráficas de potencia estática leakage del Encriptor a 20 ns

En la figura 7.6 se puede apreciar el comportamiento de la potencia en el encriptor, donde

se observa que con la implementación de más líneas de pipes optimizadas (línea azul)la

gráfica va descendiendo hasta que en 8 pipes se logra obtener un mejor resultado que el

diseño sin optimizar (línea roja).

7.2.2. Análisis de potencia estática módulo encripción 30ns

Figura 7.7 Gráficas de la potencia estática del Encriptor a 30 ns

3,4733

3,5077

3,5243 3,5421

3,7583 3,4733

4,1536

3,9285

3,6371 3,6974

3,4000

3,5000

3,6000

3,7000

3,8000

3,9000

4,0000

4,1000

4,2000

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Leakage Encriptor a 20 ns

Sin Adaptative

Retime

Con Adaptative

Retime

741,90

21,21 21,25 21,28 21,29

741,90

16,31 16,33 16,32 16,30

-100,00

0,00

100,00

200,00

300,00

400,00

500,00

600,00

700,00

800,00

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Estatica Encriptor 30 ns

Sin Adaptative

Retime

Con Adaptative

Retime

82

En la figura 7.7 se puede apreciar el comportamiento de la potencia estática del módulo

de encripción a 30ns y sus ventajas respecto a la implementación a 20 ns ya que con 8

líneas de pipes optimizadas se obtiene 16.30 mw a 30 ns mientras que a 20 ns se obtiene

20 mw.

Figura 7.8 Gráficas de potencia estática leakage del Encriptor a 30ns

En la figura 7.8 se puede apreciar que el módulo de optimización empieza a tener efecto

en la potencia de leakage a partir de la 6 línea de pipe, la cual muestra una pequeña baja

en su valor.

3,47

3,53

3,60 3,66

3,74

3,47

3,53

3,60

3,62

3,73

3,45

3,50

3,55

3,60

3,65

3,70

3,75

3,80

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Leakage Encriptor 30 ns

Sin Adaptative

Retime

Con Adaptative

Retime

83

7.2.3. Análisis de potencia estática módulo des-encripción

20ns

Figura 7.9 Gráficas de potencia estática del Des-Encriptor a 20ns

En la figura 7.9 se ven los resultados de la potencia estática del des-encriptor donde se

ven las ventajas nuevamente de la implementación del módulo de optimización para la

potencia estática.

Figura 7.10 Gráficas de potencia estática leakage del Des-Encriptor a 20ns

920,1157

44,1573 44,1722 44,1684

920,1157

25,1386 24,4425 24,1133

-200,0000

0,0000

200,0000

400,0000

600,0000

800,0000

1.000,0000

0 1 2 3 4 5

Potencia mW

Pipes

Potencia Estatica Des-Encriptor a 20 ns

Sin Adaptative

Retime

Con Adaptative

Retime

3,8251 4,0091 4,0254 4,0425

3,8251

4,6272 4,4992 4,6580

0,0000

0,5000

1,0000

1,5000

2,0000

2,5000

3,0000

3,5000

4,0000

4,5000

5,0000

0 1 2 3 4 5

Potencia mW

Pipes

Potencia Leakage Des-Encriptor a 20 ns

Sin Adaptative

Retime

Con Adaptative

Retime

84

En la figura 7.10 se puede apreciar los resultados de la potencia de leakage pero en

comparación a los obtenidos sin el módulo de optimización estos están por encima de

ellos aproximadamente en 0,6 mw.

7.2.4. Análisis de potencia estática módulo des-encripción

30ns

Figura 7.11 Gráficas de potencia estática del Des-Encriptor a 30ns

En la figura 7.11 se pueden apreciar los resultados de la potencia estática para el módulo

de des-encripción, donde se puede ver que la optimización es aproximadamente de 15

mw en cada línea de pipes.

920,1157

35,2850 35,2960 35,3080

920,1157

19,9800 19,5260 18,9700

-200,0000

0,0000

200,0000

400,0000

600,0000

800,0000

1.000,0000

0 1 2 3 4 5

Potencia mW

Pipes

Potencia Estática Des-Encriptor 30ns

Sin Adaptative

Retime

Con Adaptative

Retime

85

Figura 7.12 Gráficas de la potencia estática leakage del Des-Encriptor a 30ns

En la figura 7.12 se aprecian los resultados de potencia de leakage con el módulo de

optimización tienen una mejora aproximada de 0.2mW por línea de pipes.

3,8251

4,8626 4,8960 4,9294 3,8251

5,0560 5,0980 5,1160

0,0000

1,0000

2,0000

3,0000

4,0000

5,0000

6,0000

0 1 2 3 4 5

Potencia mW

Pipes

Potencia Leakage Des-Encriptor 30ns

Sin Adaptative

Retime

Con Adaptative

Retime

86

7.3. Análisis de potencia dinámica

Los resultados que a continuación se muestran se obtuvieron estimulando el circuito con

una imagen y un archivo de texto mostrados en la figura 5.35

7.3.1. Análisis de potencia dinámica módulo encripción

20ns

Figura 7.13 Gráficas de potencia dinámica del Encriptor a 20ns

En la figura 7.13 se aprecia el comportamiento de la potencia dinámica en el circuito a

20ns, generada con los estímulos de la imagen figura 5.35(a) y el texto figura 5.35 (b).

Los resultados de la potencia dinámica para los 2 archivos son muy similares, estos

resultados fueron tomados de los circuitos optimizados con el módulo adaptative retime.

55,1230 53,0852 51,8940

45,3600 53,8600

51,9324

50,7489

44,2800

0,0000

10,0000

20,0000

30,0000

40,0000

50,0000

60,0000

0 2 4 6 8 10Pipes

Potencia mW

Potencia Dinámica Encriptor a 20 ns

Archivo

ImagenArchivo

Texto

87

Figura 7.14 Gráficas de potencia dinámica leakage del Encriptor a 20ns

En la figura 7.16 se puede apreciar que la potencia de leakage disminuye, al

aumentar las líneas de pipes, tanto para el circuito excitado con la imagen como

con el texto

7.3.2. Análisis de potencia dinámica módulo encripción

30ns

Figura 7.15 Gráficas de potencia dinámica del Encriptor a 30ns

4,1000

3,9200

3,6370 3,5900

4,1340

3,9290

3,6370 3,5930

3,5000

3,6000

3,7000

3,8000

3,9000

4,0000

4,1000

4,2000

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Leakage Encriptor 20ns

Archivo

Imagen

Archivo

Texto

22,0300 24,0500 25,8935

28,2801

22,5400 24,1642

26,4490 28,6494

0,0000

5,0000

10,0000

15,0000

20,0000

25,0000

30,0000

35,0000

0 2 4 6 8 10Pipes

Potencia mW Potencia Dinamica Encriptor 30ns

Archivo

Texto

Archivo

Imagen

88

En la figura 7.15 se aprecia que la potencia dinámica aumenta con la implementación de

nuevos pipes, pero que sus resultados son mejores que los obtenidos a 20 ns figura 7.13.

Figura 7.16 Grafica de potencia dinámica leakage del Encriptor 30ns

En la figura 7.16 se puede apreciar que la potencia de leakage aumenta a la medida que

se aumentan las líneas de pipes, pero sus resultados son mejores que los obtenidos a 20

ns figura 7.14, para la implementación de 2 y 4 líneas de pipes

3,5300

3,6017

3,6650

3,7390

3,5420

3,6022

3,6702

3,7451

3,5000

3,5500

3,6000

3,6500

3,7000

3,7500

3,8000

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Leakage Encriptor 30ns

Archivo Texto

Archivo Imagen

89

7.3.3. Análisis de potencia dinámica modulo des-encripción

20ns

Figura 7.17 Grafica de potencia dinámica des-encripción 20ns

En la figura 7.17 se aprecian los resultados obtenidos de la potencia dinámica

obteniendo mejores resultados con cada línea de pipe nueva implementada en el

circuito.

Figura 7.18 Grafica de potencia dinámica leakage des-encripción 20ns

98,0020

81,9240 72,7736

49,9700

99,5021

81,3586

74,4354

49,5200

0,0000

20,0000

40,0000

60,0000

80,0000

100,0000

120,0000

0 2 4 6 8 10Pipes

Potencia mW

Potencia Dinámica DES-Encriptor 20ns

Archivo

Texto

Archivo

Imagen

4,6154 4,4873

4,6431

5,2400

4,6220 4,4859

4,6480

5,2300

4,4000

4,5000

4,6000

4,7000

4,8000

4,9000

5,0000

5,1000

5,2000

5,3000

0 2 4 6 8 10

Potencia mW

Pipes

Potencia Leakage DES-Encriptor 20ns

Archivo

Texto

Archivo

Imagen

90

En la figura 7.18 se aprecian los resultados para potencia de leakage donde se

puede ver claramente que sus resultados con los dos archivos de prueba son muy

similares.

7.3.4. Análisis de potencia dinámica modulo des-encripción

30ns

Figura 7.19 Grafica de potencia dinámica des-encripción 30ns

En la figura 7.19 se aprecia que la potencia dinámica disminuye con la

implementación de más líneas de pipes, y en comparación con la implementación

a 20 ns los resultados obtenidos son mejores.

87,7200

75,2100

54,3800

94,8800

75,9400

54,3800

0,0000

10,0000

20,0000

30,0000

40,0000

50,0000

60,0000

70,0000

80,0000

90,0000

100,0000

0 1 2 3 4 5Pipes

Potencia mW

Potencia Dinamica DES-Encriptor 30ns

Archivo Texto

Archivo Imagen

91

Figura 7.20 Grafica de potencia dinámica leakage des-encripción 30ns

En la figura 7.20 se pueden apreciar los resultados de la potencia de leakage a 30

ns, donde los resultados obtenidos aumentan en comparación a los resultados a

20ns figura 7.18.

5,0430

5,0912

5,1650

5,0430

5,0950 5,1200

5,0200

5,0400

5,0600

5,0800

5,1000

5,1200

5,1400

5,1600

5,1800

0 1 2 3 4 5

Potencia mW

Pipes

Potencia Leakage DES-Encriptor 30ns

Archivo Texto

Archivo Imagen

92

7.4. Comparación de resultados contra las metas de diseño.

7.4.1. Comparación módulo encripción potencia estática vs

metas de diseño

20 ns pipes Meta potencia

encriptor 0 2 3 4 8 Estática mW

Potencia Estática mW 741,8970 22,6137 20,8930 18,9897 20,0700 80,98

Potencia Leakage mW

3,4733 4,1536 3,9285 3,6371 3,6974

Tabla 7-1 Resultados de potencia estática y metas de diseño

En la tabla 7.1 se pueden apreciar todos los resultados de la potencia estática obtenida

para cada uno de las implementaciones de líneas de pipes, y en la última casilla la meta

de potencia planteada a superar como objetivo del trabajo de investigación, estos

resultados son con el circuito corriendo a 50 Mhz.


encriptor 0 2 4 6 8 Estática mW

Potencia estática 741,90 16,31 16,33 16,32 16,30 80,98

Potencia Leakage 3,47 3,53 3,60 3,62 3,73

Tabla 7-2 Resultados de potencia estática y metas de diseño.

En la tabla 7.2 se encuentran los resultados obtenidos para potencia estática, corriendo a

33 Mhz, donde se encuentran todas las implementaciones del circuito, en la última

columna se aprecian las metas de diseño a superar en los objetivos del trabajo de

investigación.

93

7.4.2. Comparación módulo encripción potencia dinámica vs

metas de diseño

Imagen pipes Meta potencia

encriptor 20 ns 2 3 4 8 Dinámica mW

Potencia Dinámica mW

55,1230 53,09 51,8940 45,3600 192,05

Potencia Leakage mW

4,1000 3,9200 3,6370 3,5900

Tabla 7-3 Resultados de potencia dinámica prueba 1 y metas de diseño.

En la tabla 7.3 se aprecian los resultados de la potencia dinámica del circuito, corriendo a

50 Mhz con estímulos basados en la imagen de prueba figura 5.35 (a), en la última

columna se encuentran las metas a superar en este diseño.

Texto pipes Meta potencia



53,86 51,93 50,75 44,28 192,05

Potencia Leakage mW

4,1340 3,9290 3,6370 3,5930


En la tabla 7.4 se aprecian los resultados de la potencia dinámica del circuito corriendo a

50 Mhz, con estímulos basados en el archivo de texto que se aprecia en la figura 5.35 (b),

en la última columna se encuentran la meta de potencia a superar en este diseño.



Potencia Dinámica 22,54 24,1642 26,4490 28,65 192,05

Potencia Leakage 3,5420 3,6022 3,6702 3,7451


En la tabla 7.5 se encuentran los resultados para la potencia dinámica del circuito

corriendo a 33 Mhz, con los estímulos generados por la figura 5.35 (a), en la última

columna se encuentra la meta de potencia dinámica a superar en este trabajo de

investigación.

94



Potencia Dinámica 22,03 24,05 25,89 28,28 192,05



En la tabla 7.6 se puede apreciar los resultados para la potencia dinámica del circuito

corriendo a 33 Mhz, con los estímulos generados por un archivo de texto que se puede

apreciar en la figura 5.35 (b), en la última columna se encuentra la meta de potencia

dinámica a superar en este trabajo de investigación.

7.4.3. Comparación módulo des-encripción potencia

estática vs metas de diseño


Des-encriptor 0 2 3 4 Estática mW

Potencia estática mW 920,1157 25,1386 24,4425 24,1133 80,98

Potencia Leakage mW

3,8251 4,6272 4,4992 4,658


En la tabla 7.7 se encuentran los resultados para la potencia estática del circuito des-

encriptor corriendo a 50 Mhz, en la última columna se encuentran la meta para la potencia

a superar por este trabajo de investigación.


Des-encriptor 0 2 3 4 Estática mW

Potencia estática 920,1157 19,9800 19,5260 18,9700 80,98



En la tabla 7.8 se puede apreciar los resultados de la potencia estática del circuito

corriendo a 33 Mhz, en la última columna se encuentran las metas a superar por este

diseño.

95

7.4.4. Comparación módulo des-encripción potencia

dinámica vs metas de diseño


Des-encriptor 20 ns 2 3 4 8 Dinámica mW


99,5021 81,3586 74,4354 49,5200 191,59

Potencia Leakage mW

4,6220 4,4859 4,6480 5,2300


En la tabla 7.9 se encuentran los resultados de potencia dinámica a 50 Mhz, con

estímulos generados por la imagen que se puede apreciar en la figura 5.35 (a), en la

última columna se puede observar la meta a superar por este diseño.


Des-encriptor 20 ns 2 3 4 8 Dinámica mW


98,0020 81,9240 72,7736 49,9700 191,59


4,6154 4,4873 4,6431 5,2400


En la tabla 7.10 se pueden apreciar los resultados de potencia dinámica a 50 Mhz, con

estímulos generados por un archivo de texto que se puede apreciar en la figura 5.35 (b),

en la última columna se puede observar la meta a superar por este diseño.


Des-encriptor 30 ns 2 3 4 Dinámica mW

Potencia Dinámica 94,8800 75,9400 54,3800 191,59

Potencia Leakage 5,0430 5,0950 5,1200


En la tabla 7.11 se pueden apreciar los resultados de potencia dinámica a 33 Mhz, con los

estímulos generados por la imagen que se puede apreciar en la figura 5.35 (a), en la

última columna la meta de diseño a superar.

96


Des-encriptor 30 ns 2 3 4 Dinámica mW

Potencia Dinámica 87,7200 75,2100 54,3800 191,59

Potencia Leakage 5,0430 5,0912 5,1650


En la tabla 7.12 se aprecian los resultados de potencia dinámica a 33 Mhz, con los

estímulos del archivo de texto descrito en la figura 5.35 (b), en la última columna se

encuentra la meta de diseño a superar.

7.4.5. Comparación del trougthput vs metas de diseño

Modulo F máx.

operación (MHz)

Bits Throughput Max

(Mbps) Performance

(Mbps)

F max 200 Mhz Meta

Throughput Max (Mbps)

Encripción 50 128 6400 320000 2.560

Des-Encripción 50 128 6400 320000 2.560

Tabla 7-13 Resultados de throughput y metas de diseño

En la tabla 7.13 se pueden apreciar los resultados obtenidos por el módulo de encripción

y des-encripción y en la última columna los resultados a superar por este trabajo de

investigación.

Los resultados que se obtuvieron en el trabajo de investigación ENERGY EFFICIENCY

ANALYSIS AND IMPLEMENTATION OF AES ON AN FPGA [29], que fueron todos

los resultados de la última columna en todas las tablas de este capítulo, fueron

obtenidos a una frecuencia de 200 Mhz, y en la tabla 7.13 se puede ver que con

una frecuencia de 50 Mhz se obtuvo un mejor throughput, lo que nos lleva a la

conclusión que no necesariamente, siempre la solución a eficiencia en un circuito

se traduce en la frecuencia de operación del mismo.

Modulo F max

operación (MHz)

Bits Throughput Max (Mbps)

Performance (Mbps)

F max 200Mhz Meta

Throughput Max (Mbps)

Encripción 33 128 4224 139392 2.560

Des-Encripción 33 128 4224 139392 2.560

Tabla 7-14 Resultados de throughput y metas de diseño

97

En la tabla 7.14 se aprecian los resultados de los módulos de encripción y des-encripción

a una frecuencia de operación de 33 Mhz, donde se puede apreciar que los resultados de

throughput son mejores que los obtenidos por la meta de desempeño en la última

columna.

7.5. Selección del diseño final

Después de haber obtenido los resultados de todos los diseños, se escoge el diseño final

del trabajo de investigación, como se comentó en el apartado 7.4.5, no siempre el diseño

que tenga la mayor velocidad de reloj es el más óptimo, siempre es necesario medir todas

las variables que se tengan para poder escoger al final.

Metas de diseño

Operación F max (Mhz) Throughput Max

(Mbps) Ps (mw) PD (mw)

Encripción 200 2560 80,98 192,05

Des-encripción 200 2560 80,98 191,59

Resultados 2 pipes


(Mbps) Ps (mw) PD (mw)

Encripción 50 6400 22,6137 55,1230

Des-encripción 50 6400 25,1386 99,5021

Resultados 2 pipes


(Mbps) Ps (mW) PD (mw)

Encripción 33 4224 16,31 22,54

Des-encripción 33 4224 19,98 94,88

Tabla 7-15 resultados diseño final

En la tabla 7.15 se puede apreciar los resultados escogidos del diseño final, los cuales

cumplen con los objetivos de mejorar la meta de diseño obtenida en ENERGY

EFFICIENCY ANALYSIS AND IMPLEMENTATION OF AES ON AN FPGA [29].

Estos diseños fueron escogidos porque superan las metas de diseño propuestas, también

porque usan menos líneas de pipes, atrasando menos nano segundos el resultado final

de la encripción y des-encripción, aparte de que manejan un nivel bueno de potencia

dinámica y estática para este diseño.

98

Se muestran estos 2 diseños, porque con estos dos tipos de frecuencia se obtuvo mayor

throughput que las metas propuestas en los objetivos.

De los dos diseños de la tabla 7.15 se decide escoger el diseño que trabaja a 50 mhz, ya

que tiene el mayor throughput y que cumple con las metas de potencia, en comparación

con las metas de diseño se puede decir que el diseño escogido tiene una buena relación

de potencia/desempeño, ya que la potencia se logró bajar a menos de la mitad y el

desempeño fue superior al doble.

Al momento de escoger otro diseño habría que tener en cuenta otras variables, como para

que dispositivo o lugar se va a utilizar el circuito, para saber que potencia es óptima en

ese lugar, que área debe manejar y si el throughput es el óptimo, pero en este caso los

resultados de la tabla 7.15 cumplen con los objetivos planteados en este trabajo de

investigación.

7.6. Trabajo futuro

En la implementación del diseño las entradas del circuito están parametrizadas, así como

las salidas, es decir que modificando este parámetro N se puede pasar de un circuito de

128 bits a uno más pequeño o también a uno más grande.

El trabajo futuro para esta investigación, seria realizar la síntesis al circuito modificando

este parámetro y analizando que efecto tiene sobre la potencia, el modificar el área del

circuito.

7.7. Anexos

Junto con el libro impreso se encuentran los siguientes anexos en formato digital

Anexo A: DVD 1, Código completo en system verilog del encriptor y del des-encriptor

Anexo B: DVD 2, informes de potencia y área generadas por la herramienta de simulación

Anexo C: DVD 2, copia del libro en formato PDF

99

Capítulo 8

8. CONCLUSIONES

La implementación del código de encripción en C, facilito la implementación en

hardware del algoritmo, ya que se pudieron tomar pruebas de datos en las

diferentes etapas del algoritmo AES, para ser comparadas con los resultados

obtenidos en hardware.

La implementación de las multiplicaciones mediante la función xtime, redujo la

complejidad del circuito, lo que logro traducir un complejo circuito de

multiplicadores a un circuito de compuertas lógicas realizando la misma función.

La función shiftrows que era el corrimiento de bits se tradujo en vez de un módulo

completo que consumía potencia, en la entrega de los bits corridos mediante

cableado a la función Bytesub, ahorrando compuertas lógicas y haciendo el

circuito más pequeño.

La implementación de las rondas en forma secuencial y no en forma de loops

permitió mejorar el desempeño del circuito, y no tener que esperar a que se

terminaran las 10 rondas para procesar un nuevo dato.

La implementación del testbench permitió la revisión de bit por bit de los datos de

salida del módulo de encripción y des-encripción, por otro lado la reutilización del

código realizado en C por el testbench permitió la revisión del hardware a alto

nivel, garantizando su funcionamiento.

La síntesis mediante el uso de las herramientas de synopsys permiten realizar un

completo análisis del circuito que se desea implementar físicamente.

La implementación de bloques de pipes permite mejorar el comportamiento del

circuito a nivel de potencia dinámica y estática, ya que la carga del circuito no la

debe resolver en un instante de tiempo, sino que es dividida en los bloques de

pipes implementados en el diseño, lo cual favorece el área y la potencia del

circuito

La implementación de la optimización adaptative retime de synopsys requiere un

gran consumo de memoria, en el servidor donde se encuentran instaladas las

herramientas, pero los resultados de la optimización son muy favorables ya que la

líneas de pipes son ubicadas en el lugar donde el circuito más carga

combinacional tiene.

100

La implementación de la herramienta POWER COMPILER de synopsys para el

cálculo de la potencia dinámica, permite generar los archivos SAIF que contienen

la información de switcheo del circuito, para así calcular y optimizar la potencia

dinámica disipada por el mismo.

La síntesis permite implementar el circuito según la tecnología del proceso que se

vaya a utilizar, como en este caso que se utilizó para el proceso la librería 90nm

que tiene las reglas de diseño de los transistores para ese tamaño

La herramienta Design Compiler de synopsys permitió realizar un análisis de área

y potencia del circuito, lo cual es una ventaja ya que al momento de querer pasar

el circuito de simulación a físico, se tiene un completo análisis del comportamiento

que va a tener.

Con la implementación de las líneas de pipes con la optimización, se podía ver

como el área se beneficiaba con cada línea de pipe implementada en el circuito.

La variación de la frecuencia de operación del circuito, permitió obtener resultados

del comportamiento del mismo y poder comparar cual es el efecto de la frecuencia

en la potencia y área en el circuito.

La implementación de líneas de pipes permitió reducir la potencia disipada del

circuito, ya que todas las funciones del circuito no corrían simultáneamente como

lo hacía el diseño con 0 líneas de pipes.

La implementación de relojes de alta frecuencia, no es siempre sinónimo de mejor,

la implementación de circuitos digitales orientados a buen desempeño y

throughput no necesariamente contempla obligatoriamente niveles de reloj

elevados, aunque es parte de las variables a tener en cuenta.

101

Bibliografía

[1] Mónica C. liberatori “DESARROLLO DE ENCRIPTADO AES EN FPGA”,

Universidad Nacional de la plata Argentina. Febrero de 2006.

[2] Grupo de investigación MACRYPT. IMPLEMENTACION DE AES EN FPGA,

Escuela de Ingeniería Universidad de los llanos – Colombia JUNIO de 2010

[3] Francisco País Suárez. “COMPARATIVA ENTRE LOS ALGORITMOS DE

CIFRADO DES Y RIJNDAEL” Universidad de la Coruña Febrero de 2003

[4] Heidy Marisol Marín Castro “IMPLEMENTACIÓN DEL ALGORITMO DE

ENCRIPTADO AES EN HANDEL-C PARA UN FPGA” – Universidad autónoma de

Puebla, Octubre de 2004

[5] Jenny Elena Aguilar López “ARQUITECTURA EN UN FPGA PARA

ENCRIPTACIÓN AES” – Universidad Autónoma de Puebla, Octubre de 2004

[6] Emmanuel López Trejo “IMPLEMENTACIÓN EFICIENTE EN FPGA DEL MODO

CCMUSANDO AES”- Instituto Politécnico Nacional de México, Septiembre 2005

[7] Patricia V. Maizel “IMPLEMENTACIÓN DEL ALGORITMO A.E.S. (ADVANCED

ENCRYPTION STANDARD)” Junio 2004

[8] Alfonso Muñoz Muñoz “SEGURIDAD EUROPEA PARA EEUU ALGORITMO

CRIPTOGRÁFICO RIJNDAEL”, Madrid - Septiembre de 2004

[9] Rubén Darío Nieto Londoño “IMPLEMENTACIÓN ASÍNCRONA DE LAS

FUNCIONES MIXCOLUMN E INVMIXCOLUMN DEL ALGORITMO DE RIJNDAEL”

– Escuela de ingeniería Eléctrica y electrónica Universidad del valle, Julio de 2009

[10] Tsutomu Sasao “AN FPGA DESIGN OF AES ENCRYPTION CIRCUIT WITH 128-

BIT KEYS” - Meiji University, Kawasaki, Kanagawa, 214–8571, Japan 2005

[11] HELION Technology Limited, “High performance AES (Rijndael) cores for Altera

FPGA,” available at htthroughput://www.heliontech.com/core2.htm 2004

[12] Amphion Semiconductor, “CS5210-40: High performance AES encryption cores,”

available at htthroughput://www.amphion.com/cs5210.htm. 2003

[13] Juan Manuel Guzmán Salas “IMPLEMENTACIÓN EN UN FPGA DE

ENCRIPTACIÓN DOBLE RONDA COMO SOLUCIÓN AL TEOREMA LR” Instituto

Politécnico México D.F. Nacional diciembre 2007

[14] Laura Vargas “ESTUDIO Y EVALUACIÓN DE ALGORITMOS DE ENCRIPTACIÓN

PARA LA PROTECCIÓN DE DATOS PARA SU IMPLEMENTACIÓN USANDO

http://www.heliontech.com/core2.htm

http://www.amphion.com/cs5210.htm

102

LENGUAJES DE DESCRIPCIÓN DE HARDWARE” Universidad de Costa Rica

2010

[15] Jan M. Rabaey “DIGITAL INTREGATED CIRCUITS – A DESIGN PERSPECTIVE

(2ND ED)”, Anantha 2004.

[16] John Williams “DIGITAL VLSI DESIGN WITH VERILIOG” Springer 2008 U.S.A

[17] Richard Munden “ASIC AND FPGA VERIFICATION - A GUIDE TO COMPONENT

MODELING” 2006

[18] Samir Palnitkar “VERILOG HDL - A GUIDE TO DIGITAL DESIGN AND

SYNTHESIS” 2006 Springer Science+Business Media, Inc

[19] Zainalabedin Navabi “DIGITAL.DESIGN AND IMPLEMENTATION WITH FIELD

PROGRAMMABLE DEVICES”, KLUWER ACADEMIC PUBLISHERS 2005 Boston

USA.

[20] Janick Bergeron “WRITING TESTBENCHES USING SYSTEMVERILOG”, 2006

Springer Science+Business Media, Inc

[21] Chris Spear “SYSTEMVERILOG FOR VERIFICATION”, 2006 Springer

Science+Business Media, Inc

[22] Synopsys Inc. “GENERIC LIBRARIES FOR SYNOPSYS” User Guide 2005

Synopsys, Inc U.S.A

[23] Synopsys Inc. “POWER COMPILER” User Guide 2005 Synopsys, Inc U.S.A.

[24] Synopsys Inc. “PRIME POWER MANUAL SYNOPSYS”, User Guide 2005

Synopsys, Inc. U.S.A. National Institute of Technology Rourkela-769008, (2011)

[25] Ramesh Guntupalli, “A VERILOG-BASED SIMULATION METHODOLOGY FOR

ESTIMATING POWER AND AREA” Universidad Complutense de Madrid (2011)

[26] Palomino Guzmán Abelardo “DISEÑO E IMPLEMENTACIÓN DE

ALGORITMOS CRIPTOGRÁFICOS SOBRE FPGA”, 2006 Universidad

Complutense de Madrid

[27] Ignacio Algredo-Badillo, René Cumplido-Parra, Claudia Feregrino-Uribe “DISEÑO Y DESARROLLO DE UNA PLATAFORMA CRIPTOGRÁFICA RECONFIGURABLE DE ALTO DESEMPEÑO” Instituto Nacional de Astrofísica, Óptica y Electrónica, INAOE 2009

[28] Alejandro Segredo, Enrrique Zabala, Gustavo Bellora “DISEÑO DE UN

PROCESADOR CRIPTOGRAFICO RIJNDAEL EN FPGA” Facultad de ingeniería Universidad ORT Urugay 2010

[29] David Kenney “ENERGY EFFICIENCY ANALYSIS AND IMPLEMENTATION OF

AES ON AN FPGA” Universidad Warterloo, Ontario, Canada 2008

103

[30] CADENCE Inc. software para implementación de RTL y análisis de potencia htthroughput://www.cadence.com/solutions/lp/Pages/Default.aspx [Consulta: Lunes, 10 de enero de 2013]

[31] MENTOR GRAPHICS Inc. software para la implementación de RTL y análisis de

potencia htthroughput://www.mentor.com/products/ic_nanometer_design/ [Consulta: Lunes, 11 de enero de 2013]

[32] Synopsys Inc. Software de diseño e implementación de RTL y análisis de potencia

htthroughput://www.synopsys.com/mhome.aspx [Consulta: Lunes, 10 de enero de 2013]

[33] José de Jesús Ángel “ADVANCED ENCRYPTION STANDAR” Centro de

Investigación y de Estudios Avanzados del Instituto Politécnico Nacional, México

2005

http://www.cadence.com/solutions/lp/Pages/Default.aspx

http://www.mentor.com/products/ic_nanometer_design/

http://www.synopsys.com/mhome.aspx

Implementación de un diseño con una buena relación de ...

Documents

Transcript of Implementación de un diseño con una buena relación de ...