1

UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

(Universidad del Perú, DECANA DE AMÉRICA)

FACULTAD DE INGENIERÍA DE SISTEMAS E INFORMÁTICA

Escuela Profesional de Ingeniería de Sistemas

“Año de la universalización de la salud”

CURSO:
Matemática Discreta

DOCENTE:
Moquillaza Henriquez, Santiago Domingo

INTEGRANTES:
Antonio Cunto James Gabriel
Guevara Ames Jhonatan Sebastian Ysrael
Huarcaya Gonzales Fiorela
Pantoja Pimentel Kevin Renzo
Ramos Chiclla Arnold Jesús
Quispe Ñaupa Wiliam Luis

2020
 2

Tabla de Contenido

Introducción 3

Certificado Digital 4
Elementos de Certificados Digitales 4
Certificados X.509 4

Firma Digital 7
Función Hash 8
Proceso de firmado 9
Usos de la firma digital 9

Token digital 10
Principales tokens utilizados 10
Tarjetas inteligentes 10
Token usb o token criptográfico 11
Uso del token en el proceso de firma digital 11
Algoritmo RSA 12

Ejemplos de Funciones HASH 13

MD5 (Message Digest Algorithm 5) 13
Concepto del algoritmo MD5 13
Descripción del Algoritmo MD5: 13
SHA-1 16
Concepto del algoritmo SHA-1 16
Descripción del Algoritmo SHA-1 16
SHA-2 18
Concepto del algoritmo SHA-2 18
Descripción del Algoritmo SHA-512 19
Simulación 21
Código C++ 22
Resultados 25

Conclusiones 26

Referencias 27
 3

Introducción

Dada la inseguridad y la demora que conlleva los métodos tradicionales en el proceso de

firma de documentos, u otras operaciones, el ser humano vio la posibilidad de agilizar los

procesos utilizando los medios digitales, gracias al avance exponencial que tiene en el siglo XXI,

y utilizar la criptografía, con el fin de aminorar la vulnerabilidad que conllevan estos medio.

Teniendo en cuenta la sustancial necesidad de conocer y entender el tema mencionado, se detalla

de manera precisa y concreta el concepto, la utilidad e importancia del contrato y la firma digital

como medios seguros en diversos procesos, así también como el uso de tokens como dispositivos

de almacenamiento seguro. Además, el presente trabajo contiene conceptos y descripciones

detalladas de los algoritmos de las funciones hash, que han sido utilizadas desde los finales del

siglo anterior hasta la actualidad, como MD5, SHA – 1 y SHA – 2. También, de forma breve, se

explica el algoritmo de criptografía asimétrica RSA.

 4

Certificado Digital

Un certificado digital o certificado electrónico según Díaz et al. (2014) es “un documento

que certifica que una entidad determinada, como puede ser un usuario, una máquina, un

dispositivo de red o un proceso, tiene una clave pública determinada” (p.31).

Elementos de Certificados Digitales

Para Cardador (2014) los pasos para incorporar los elementos de los certificados digitales
son los siguientes:

1. Recibir el mensaje.

2. Recuperar del mensaje la firma digital con el valor hash de cifrado.

3. Recuperar el mensaje.

4. Cálculo del hash del mensaje.

5. Recuperación de la clave pública del remitente que viene en el certificado digital.

6. Descifrar con la clave pública del remitente el valor hash.

7. Comparar el valor de hash descifrado con el valor obtenido en la recepción del

mensaje.

8. Si los valores coinciden, el mensaje es válido.

Certificados X.509

Los certificados X.509 presentan 3 versiones, siendo la última versión X.509v3. Esta

nueva versión extendía las anteriores con un conjunto de campos adicionales que debían estar
 5

definidos en estándares o registrados por alguna comunidad u organización. (Gonzáles et al.

2014, p.38).

El principal contenido de los certificados X.509v3 según Gonzáles et al. (2014) es la

siguiente:

● Versión: número de la versión del certificado.

● Número de serie: número entero único asignado por la AC emisora.

● Identificador del algoritmo de firma: identificador de firma del certificado.

● Nombre del emisor: nombre de la AC que emite el certificado.

● Validez: fecha de inicio de validez del certificado y fecha de fin.

● Nombre del sujeto: nombre del usuario al que se le otorga el certificado.

● Información de la clave pública del sujeto: clave pública del sujeto, parámetros

asociados a la clave e identificador del algoritmo con el que ha de utilizarse la

clave.

● Firma digital del emisor: firma de la AC emisora.

● Extensiones (opcional): información adicional.

A continuación, se muestra un ejemplo de certificado digital X.509v3 de una CA:

Certificate:
Data:
Version: 3 (0x2)
Serial Number: 1 (0x1)
Signature Algorithm: md5WithRSAEncryption
Issuer: C=ZA, ST=Western Cape, L=Cape Town, O=Thawte Consulting cc,
OU=Certification Services Division,
CN=Thawte Server CA/Email=server-certs@[Link]
Validity
 6

Not Before: Aug 1 [Link] 2010 GMT

Not After : Dec 31 [Link] 2020 GMT
Subject: C=ZA, ST=Western Cape, L=Cape Town, O=Thawte Consulting cc,
OU=Certification Services Division,
CN=Thawte Server CA/Email=server-certs@[Link]
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
RSA Public Key: (1024 bit)
Modulus (1024 bit):
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Basic Constraints: critical
CA:TRUE
Signature Algorithm: md5WithRSAEncryption
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
[Link]
70:47

Oppliger (2014) nos explica que Thawte es una de las autoridades certificantes raíz

reconocida por Microsoft y Netscape. Este certificado ya viene con el navegador web

(probablemente pueda encontrarse listado como "Thawte Server CA" en las opciones de

seguridad) y es confiable por defecto. Como certificado confiado globalmente de larga vida

(nótese la fecha de vencimiento) que puede firmar prácticamente cualquier cosa (nótese la falta
 7

de limitaciones), su clave privada correspondiente debe ser una de las más ocultas del mundo.

(p.88)

Firma Digital

La firma digital para Soriano (2014) es “una firma electrónica que se puede utilizar para

autenticar la identidad del remitente de un mensaje o el firmante de un documento. Asimismo,

también garantiza la integridad del mensaje” (p. 56). Esto permite y asegura que el documento

que el remitente envía pueda ser auténtico y que la firma dispuesta no pueda ser generada por

ninguna otra persona ajena al usuario original.

La firma digital entre sus muchas características permite el no repudio, esto se refiere al

hecho de que, si un documento es enviado con la firma de un remitente, dicho remitente no podrá

negar haber firmado el documento en mención. A su vez, las firmas digitales han de cumplir con

las mismas características de las firmas manuscritas, deben de ser auténticas, infalsificables,

inalterables y no reutilizables. (García, 2018, p. 97)

Una de las grandes ventajas de la firma digital frente a la manuscrita lo menciona Reyes

(2006) “permiten asociar la identidad del firmante con el documento avalado y detectar

modificaciones del mismo (Integridad)” (p. 55). Algo que normalmente sucede con las firmas

manuscritas es que los documentos firmados pueden ser alterados y la firma seguirá

referenciándose al usuario y este debe de hacerse responsable de dicho documento adulterado.

Una firma digital implica un proceso de encriptación asimétrica ya que su metodología

ofrece mayor robustez. Este proceso de encriptación asimétrica utiliza dos claves distintas que
 8

tienen una relación matemática. La primera clave (pública) se encarga de la codificación y la

segunda clave (privada) permite el descifrado. (García, 2018, p. 97)

Para poder construir una firma digital que tenga como base una infraestructura de clave

pública se requiere una función hash (SHA-2, SHA-3), que según García (2018) “transforma un

texto de longitud variable en un bloque de longitud fija en forma de resumen que es irreversible

(no se puede recuperar un texto a partir de su resumen)” (p. 100). También es necesario un

algoritmo asimétrico (RSA, DSS, ECDSA) que genera las dos claves, siendo la clave privada la

que permite firmar y la clave pública autenticar la firma.

Función Hash

Dentro del uso de la firma digital las funciones hash tienen un papel muy importante.

Podemos definir a una función hash en palabras de García Rojas (2008) como:

Método para generar claves o llaves que identifican de manera casi unívoca a un

documento, archivo, registro, etc. Como resultado de la aplicación de esta función o

algoritmo a un documento, archivo o registro dado se obtiene, lo que se denomina, un

hash (llamado también “resumen”). (p.13)

Entonces, podemos entender a una función hash como un proceso de transformación de

una cadena binaria o un mensaje de una determinada longitud en otra cadena binaria de longitud

constante y menor a la inicial (mayormente). Esta nueva cadena binaria se conoce como valor

hash y es empleado para la emisión de certificados, firmas digitales, generación de claves, etc.

(Escalona, 2012, p. 1)
 9

Proceso de firmado

El proceso de firmado de un documento inicia con la creación de este por parte del

remitente, luego le aplica una función hash y en seguida lo cifra con su clave privada. Es

importante mencionar que cada documento firmado debe de ser revisado por una Autoridad de

Certificación, que validará su origen y contenido, y luego, si todo es correcto, será enviado al

receptor en conjunto con el Certificado Digital. Paso seguido el receptor recibe el documento

conformado tanto por el mensaje como por la firma que procederá a descifrar con la clave

pública del remitente y comparar el hash obtenido con el hash resumen del mensaje. Si ambos

son iguales el mensaje es auténtico. (García, 2018, p. 100)

Es importante mencionar que el proceso de generar y verificar una firma digital basada en

PKI (Infraestructura de clave pública) según Cuno (2015) “se cimienta en dos entes: i. Autoridad

de Certificación […] ii. Lista de Revocación de Certificados, la cual debe estar

permanentemente actualizada por la autoridad de certificación correspondiente” (como se citó en

García, 2018, p. 101). El papel de la Autoridad de Certificación es importante, ya que es la que

genera la confianza en el receptor de que el remitente tiene todo el respaldo legal al enviar el

mensaje.

Usos de la firma digital

En su mayoría las firmas digitales son usadas para la autenticación e identificación de

entidades, pero también tiene un uso en el comercio electrónico, en la identificación de la

autenticidad de un sitio web, para prevenir la manipulación de un software, etc. Hoy en día
 10

tienen una relevancia bastante significativa debido al gran auge de las transacciones o las

comunicaciones de forma digital ya que se exigen que estas sean de forma legal y no fraudulenta.

Token digital

Este dispositivo nos brinda seguridad en base a la criptografía es el token, “sirve para

usarse en la generación y almacenamiento seguro de contraseñas, certificados digitales,

autenticación fuerte segura, firmas digitales y encriptación. (De la Motta y Vela, 2008, p. 50).

Además, algunos tokens, por cuestiones de mayor seguridad, “emplean mecanismos o sistemas

adicionales, como tamper proof (ante cualquier intento malintencionado, el token dejará

evidencia) o tamper resistant (ante cualquier uso malintencionado, el chip se dañará y quedará

inservible)” (Aguilar, 2016, p.45).

Principales tokens utilizados

“Cada usuario tiene un par de claves asimétricas únicas (claves públicas y privadas) para

firmar digitalmente un documento. Normalmente, (...) debe tener un dispositivo de seguridad (...)

que almacena la clave privada y puede acceder a ella ingresando su PIN ”(Rezaeighaleh et al. ,

2018, p. 182).

Tarjetas inteligentes

Parecida a una tarjeta de crédito convencional, en dimensiones, esta tarjeta contiene un

procesador criptográfico y circuitos integrados que permiten almacenar una lógica programada

(Aguilar, 2016, p. 44). Para poder leer la información del chip de este tipo de tarjetas se conectan
 11

a un lector de forma directa o por medios que no necesitan contacto, como radio frecuencias.

Sin embargo, para poder utilizarse es necesaria la digitación de un PIN que servirá como clave de

acceso.

Su mecanismo es el siguiente: una vez el usuario verificó y aprobó el contenido de algún

documento, el terminal de la tarjeta realizará una función hash, luego se envía el hash del

documento a la tarjeta inteligente para que, mediante la clave privada, genere la firma digital.

(Rezaeighaleh et al., 2018, p.182)

“La tecnología de tarjetas inteligentes sigue estándares internacionales como el ISO/IEC

7816 y ISO/IEC 14443”(De la Motta & Vela, 2008, p. 49)

Token usb o token criptográfico

Este dispositivo “proporciona seguridad a los datos con base en la tecnología Smartcard y

sin requerir lectores especiales” (De la Motta y Vela, 2008, p. 50). Esto brinda una mayor

versatilidad e independencia al momento de hacer operaciones dado que cubre “todas las

necesidades de autenticación (acceso vía web, acceso vía VPN y acceso a la red) y proporciona

seguridad de archivos y de laptops” (De la Motta y Vela, 2008, p. 50). “Estos tokens deben

estar certificados con: FIPS 140-2 y/o CC EAL 4+” (Aguilar, 2016, p. 45).

Uso del token en el proceso de firma digital

La firma digital varía en cada documento, esto debido a que depende de tanto del

contenido del documento y de la clave privada (Álvarez et al., 2005, p. 36). La que otorga la

variabilidad de la firma es el contenido del documento, dado que la clave privada es fija. La
 12

clave privada, como el mismo nombre lo indica, es únicamente de propiedad del usuario, esta

clave será almacenada en el token y se requerirá en cada proceso, al momento de encriptar el

documento que previamente ha pasado por una función hash, de firma de un documento.

Algoritmo RSA

Mohit y Biswas (2017) nos mencionan que “El RSA fue desarrollado por Ron Rivest,

Adi Shamir y Len Adleman en el año 1976 (…) y es el algoritmo de clave pública más utilizado

en criptografía” (p. 67). Es un tipo de algoritmo de criptografía asimétrica utilizado en la

encriptación de la función hash del documento en el proceso de firma digital.

El proceso que se debe seguir, según Mohit y Biswas (2017), es el siguiente:

1.- Elija dos números primos grandes distintos p y q

2.- Calcule n = p × q y la función de Euler Ф(n) = (p-1) × (q-1), luego elimine p y q

3.- Seleccione un número e tal que 1 < e < Ф(n) y además sea primo relativo a Ф(n)

4.- Calcule el inverso multiplicativo d tal que e × d ≡ 1 mod Ф(n)

Una vez calculado estos valores podremos encriptar y desencriptar:

Encriptar:

1.- Elija cualquier texto sin formato de k bits m tal que k ≤ log2(n), donde n es el módulo

público.

2.- Calcular texto cifrado c = me (mod n)

Descifrado:

Calcular texto sin formato m = cd (mod n)

 13

Ejemplos de Funciones HASH

MD5 (Message Digest Algorithm 5)

Concepto del algoritmo MD5

Badillo, et al. (2011) nos explican que MD5 (Message Digest Algorithm 5, Algoritmo de

Ordenación de Mensajes 5) es un algoritmo seguro desarrollado por RSA Data Security Inc.

MD5 es una función resumen de 128 bits, que toma como entrada un mensaje de tamaño

arbitrario y produce como salida un resumen del mensaje, una cadena de 32 caracteres. Este es

un tipo de encriptación unidireccional, es decir, se puede encriptar, pero no se puede

desencriptar. El MD5 no sirve para cifrar un mensaje ya que lo destruye completamente, la

información no es recuperable de ninguna manera ya que hay pérdida de información (párr. 8).

Descripción del Algoritmo MD5:

Supongamos que tenemos un mensaje de 'b' bits como entrada, y queremos encontrar su

digest (valor hash o resumen). Leopoldo (s.f) menciona 5 pasos para definir nuestro algoritmo:

Paso 1: Adición de Bits. Se agrega un bit en “1” y tantos bits en “0” como sea necesario

para que el mensaje sea congruente con 448, módulo 512.

Paso 2: Longitud del mensaje. El siguiente paso es agregar una representación de 64

bits. En este momento, este mensaje tiene una longitud que es múltiplo exacto de 16. Sea

M[0...N-1] las palabras de 32 bits del mensaje resultante, donde N es múltiplo de 16.
 14

Paso 3: Inicializar el Buffer MD (Message Digest). Se inicializan cuatro variables de

encadenamiento.

𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝐴: 01 23 45 67 ; 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝐵: 89 𝑎𝑏 𝑐𝑑 𝑒𝑓
𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝐶: 𝑓𝑒 𝑑𝑐 𝑏𝑎 98 ; 𝑅𝑒𝑔𝑖𝑠𝑡𝑟𝑜 𝐷: 76 54 32 10

Paso 4: Procesado del Mensaje en bloques de 16 palabras. El ciclo del algoritmo

comienza y continúa cuando hay bloques de 512 bits en el mensaje. El principal bucle tiene

cuatro rondas similares. El resultado de hacer frente a cuatro rondas en diferentes variables de

encadenamiento es ilustrado de la siguiente manera: a obtiene A, b obtiene B, c obtiene C, d

obtiene D. Cada operación realiza una operación no lineal, funcionan en tres de a, b, c y d. Luego

agrega el resultado a la derecha un número variable de bits y suma el resultado a uno de a, b, c y

d. Finalmente, el resultado reemplaza uno de a, b, c y d

𝐹(𝑋, 𝑌, 𝑍) = (𝑋∧𝑌)∨((∼ 𝑋)∧𝑍) ; 𝐺(𝑋, 𝑌, 𝑍) = (𝑋∧𝑌)∨(𝑌∧(∼ 𝑍))

𝐻(𝑋, 𝑌, 𝑍) = 𝑋⨁𝑌⨁𝑍 ; 𝐼(𝑋, 𝑌, 𝑍) = 𝑌⨁(𝑋∨(∼ 𝑍))

Pseudocódigo.

Desde i = 0 hasta N/16-1 hacer //Procesar cada bloque de 16 palabras

Desde j = 0 hasta 15 hacer //Copiar el bloque i en X

Poner en X[j] el valor M[i*16+j].

fin

𝐴𝐴 = 𝐴 ; 𝐵𝐵 = 𝐵 ; 𝐶𝐶 = 𝐶 ; 𝐷𝐷 = 𝐷 //Grabamos los valores A,B,C y D

/* Primera Vuelta: Utilizamos [abcd k s i] para denotar la operación */

𝑎 = 𝑏 + ((𝑎 + 𝐹(𝑏, 𝑐, 𝑑) + 𝑋[𝑘] + 𝑇[𝑖]) ⋘ 𝑠)

 15

/* Hacer las siguientes 16 operaciones. */

[𝐴𝐵𝐶𝐷 0 7 1] [𝐷𝐴𝐵𝐶 1 12 2] [𝐶𝐷𝐴𝐵 2 17 3] [𝐵𝐶𝐷𝐴 3 22 4]

[𝐴𝐵𝐶𝐷 4 7 5] [𝐷𝐴𝐵𝐶 5 12 6] [𝐶𝐷𝐴𝐵 6 17 7] [𝐵𝐶𝐷𝐴 7 22 8]
[𝐴𝐵𝐶𝐷 8 7 9] [𝐷𝐴𝐵𝐶 9 12 10] [𝐶𝐷𝐴𝐵 10 17 11] [𝐵𝐶𝐷𝐴 11 22 12]
[𝐴𝐵𝐶𝐷 12 7 13] [𝐷𝐴𝐵𝐶 13 12 14] [𝐶𝐷𝐴𝐵 14 17 15] [𝐵𝐶𝐷𝐴 15 22 16]

/* Segunda Vuelta: Utilizamos [abcd k s i] para denotar la operación */

𝑎 = 𝑏 + ((𝑎 + 𝐺(𝑏, 𝑐, 𝑑) + 𝑋[𝑘] + 𝑇[𝑖]) ⋘ 𝑠)

[𝐴𝐵𝐶𝐷 1 5 17] [𝐷𝐴𝐵𝐶 6 9 18] [𝐶𝐷𝐴𝐵 11 14 19] [𝐵𝐶𝐷𝐴 0 20 20]

[𝐴𝐵𝐶𝐷 5 5 21] [𝐷𝐴𝐵𝐶 10 9 22] [𝐶𝐷𝐴𝐵 15 14 23] [𝐵𝐶𝐷𝐴 4 20 24]
[𝐴𝐵𝐶𝐷 9 5 25] [𝐷𝐴𝐵𝐶 14 9 26] [𝐶𝐷𝐴𝐵 3 14 27] [𝐵𝐶𝐷𝐴 8 20 28]
[𝐴𝐵𝐶𝐷 13 5 29] [𝐷𝐴𝐵𝐶 2 9 30] [𝐶𝐷𝐴𝐵 7 14 31] [𝐵𝐶𝐷𝐴 12 20 32]

/* Tercera Vuelta: Utilizamos [abcd k s t] para denotar la operación */

𝑎 = 𝑏 + ((𝑎 + 𝐻(𝑏, 𝑐, 𝑑) + 𝑋[𝑘] + 𝑇[𝑖]) ⋘ 𝑠)

[𝐴𝐵𝐶𝐷 5 4 33] [𝐷𝐴𝐵𝐶 8 11 34] [𝐶𝐷𝐴𝐵 11 16 35] [𝐵𝐶𝐷𝐴 14 23 36]
[𝐴𝐵𝐶𝐷 1 4 37] [𝐷𝐴𝐵𝐶 4 11 38] [𝐶𝐷𝐴𝐵 7 16 39] [𝐵𝐶𝐷𝐴 10 23 40]
[𝐴𝐵𝐶𝐷 13 4 41] [𝐷𝐴𝐵𝐶 0 11 42] [𝐶𝐷𝐴𝐵 3 16 43] [𝐵𝐶𝐷𝐴 6 23 44]
[𝐴𝐵𝐶𝐷 9 4 45] [𝐷𝐴𝐵𝐶 12 11 46] [𝐶𝐷𝐴𝐵 15 16 47] [𝐵𝐶𝐷𝐴 2 23 48]
/* Cuarta Vuelta: Utilizamos [abcd k s t] para denotar la operación */

𝑎 = 𝑏 + ((𝑎 + 𝐼(𝑏, 𝑐, 𝑑) + 𝑋[𝑘] + 𝑇[𝑖]) ⋘ 𝑠)

[𝐴𝐵𝐶𝐷 0 6 49] [𝐷𝐴𝐵𝐶 7 10 50] [𝐶𝐷𝐴𝐵 14 15 51] [𝐵𝐶𝐷𝐴 5 21 52]

[𝐴𝐵𝐶𝐷 12 6 53] [𝐷𝐴𝐵𝐶 3 10 54] [𝐶𝐷𝐴𝐵 10 15 55] [𝐵𝐶𝐷𝐴 1 21 56]
[𝐴𝐵𝐶𝐷 8 6 57] [𝐷𝐴𝐵𝐶 15 10 58] [𝐶𝐷𝐴𝐵 6 15 59] [𝐵𝐶𝐷𝐴 13 21 60]
[𝐴𝐵𝐶𝐷 4 6 61] [𝐷𝐴𝐵𝐶 11 10 62] [𝐶𝐷𝐴𝐵 2 15 63] [𝐵𝐶𝐷𝐴 9 21 64]

/* Luego, realizar las siguientes sumas. */

𝐴 = 𝐴 + 𝐴𝐴 ; 𝐵 = 𝐵 + 𝐵𝐵 ; 𝐶 = 𝐶 + 𝐶𝐶 ; 𝐷 = 𝐷 + 𝐷𝐷
 16

Paso 5: Salida. Los resúmenes de mensajes generados como salida son A, B, C, D. La

salida comienza con bytes bajos (de menor peso) de A y termina con bytes altos (de mayor peso)

de D.

SHA-1

Concepto del algoritmo SHA-1

El SHA-1 es un algoritmo hash seguro aprobado por los Estándares Federales de

Procesamiento de Información (FIPS) emitidos por el Instituto Nacional de Estándares y

Tecnología (NIST). De acuerdo con Lin et al. (2019), el SHA-1 trabaja con datos de entrada

menor a 264 para producir un resumen de mensaje de longitud de 160 bits. La longitud del

mensaje de entrada puede ser menor que 512 bits, pero cuando es mayor, el mensaje es dividido

en varios fragmentos de mensajes (p. 493).

Además, de acuerdo con Lin et al. (2019), el resumen del mensaje original y los nuevos

bloques de mensajes son utilizados para producir nuevos resúmenes de mensajes. Como ya se

explicó previamente, este tipo de algoritmos son seguros porque son extremadamente difíciles de

regresar al mensaje original a partir del resumen. La función hash tiene un efecto de avalancha

muy fuerte pues, un pequeño cambio en el mensaje causará cambios drásticos en el resumen del

mensaje (p. 493).

Descripción del Algoritmo SHA-1

El siguiente procedimiento para el desarrollo del algoritmo SHA-1 fue propuesto por

Long (2019):
 17

Paso 1: Inicializamos las variables. El autor supone que la longitud del mensaje a ser

resumido es mucho menor que 264.

h0 = 0x67452301 h3 = 0x10325476

h1 = 0xEFCDAB89 h4= 0xC3D2E1F0

h2 = 0x98BADCFE

Paso 2: Pre - procesamiento. Añadimos el bit “1” al mensaje, luego añadimos k bits

“0”, donde k es el mínimo número >= 0, tal como la longitud del mensaje resultante es

congruente con 448 (mod 512). Luego, añadimos la longitud del mensaje, en bits, como un

entero big - endian de 64 bits.

Paso 3: Se procesa el mensaje en fragmentos consecutivos de 512 bits. Se divide el

mensaje en fragmentos de 512 bits para cada fragmento, y el fragmento dividido, en dieciséis

palabras big – endian de 32 bits.

w[i],0≤i≤15

Paso 4: Extender las dieciséis palabras de 32 bits ochenta palabras de 32 bits.

for i from 16 to 79

w[i]=w[i-3]⊕w[i-8]⊕w[i-14]⊕w[i-16] leftrotate 1

Paso 5: Inicializar el valor hash para el fragmento.

a := h0 … e := h4

Paso 6: Bucle Principal.

for i from 0 to 79 If 0<= i <=19 then

 18

f = (b ˄ c) v ((¬b) ˄ d) f=b⊕c⊕d
k = 0x5A827999 k = 0xCA62C1D6
else if 20 <= i <= 39 temp = (a leftrotate 5) + f + e + k + w[i]
f=b⊕c⊕d e=d
k = 0x6ED9EBA1 d=c
else if 40 <= i <= 59 c = b leftrotate 30
f = (b ˄ c) v (b ˄ d) v (c ˄ d) b=a
k = 0x8F1BBCDC a = temp

else if 60<= i <= 79

Añadir el hash de este bloque al resultado:

h0 = h0 + a … h4= h4 + e

Producir el valor hash final (big - endian).

Digest = hash = h0 append h1 append h2 append h3 append h4

Las siguientes expresiones alternativas podrían ser capaces de calcular f en el bucle principal.

(0 <= i <= 19) f = d ⊕ (b ^ (c ⊕ d)) (alternative)

(40 <= I <= 59) f = (b ^ c) v (d ^ (b ^ c)) (alternative 1)
(40 <= I <= 59) f= (b ^ c) v (d ^ (b ⊕ c)) (alternative 2)
(40 <= I <= 59) f= (b ^ c) + (d ^ (b ⊕ c)) (alternative 3)

SHA-2

Concepto del algoritmo SHA-2

SHA-2 pertenece a la familia de criptográficos SHA, fue diseñado por la Agencia de

Seguridad Nacional de EE. UU. (NSA). En 2001, NIST introdujo sus dos versiones, SHA-256

(32 bits) y SHA-512 (64 bits) como un Estándar Federal de Procesamiento de Información de los
 19

EE. UU. Años posteriores se agregaron otras versiones truncadas, SHA-224, que es una versión

de SHA-256, y SHA 384 que es una versión de SHA-512. En pocas palabras, SHA-2 es el

conjunto de algoritmos hash criptográficos, excluyendo SHA-1 (Ghoshal et al., 2020, p.110).

Martino y Cilardo (2020) mencionan como SHA-2 sigue siendo muy utilizado y es

crucial en muchas aplicaciones, a pesar de que el NIST, en 2015, estandarizó una nueva función

hash, SHA-3, la cual no ha alcanzado a generalizarse(párr. 8).

Descripción del Algoritmo SHA-512

A continuación se muestran los pasos del algoritmo SHA-512. Se usó como base el

trabajo de Long (2019) y algunas contribuciones de otros autores.

Paso 1: inicializar variables y constantes. Como dicen Martino y Cilardo(2020) las

variables utilizadas son los primeros 64 bits de la parte decimal de las raíces cuadradas de los

primeros ocho números primos(prr. 14).

0 0
𝐻0→𝑎 = 0𝑥6𝑎09𝑒667𝑓3𝑏𝑐𝑐908 𝐻4 → 𝑒 = 0𝑥510𝑒527𝑓𝑎𝑑𝑒682𝑑𝑙

0 0
𝐻1 → 𝑏 = 0𝑥𝑏𝑏67𝑎𝑒8584𝑐𝑎𝑎73𝑏 𝐻5 → 𝑓 = 0𝑥9𝑏05688𝑐2𝑏3𝑒6𝑐1𝑓

0 0
𝐻2 → 𝑐 = 0𝑥3𝑐6𝑒𝑓372𝑓𝑒94𝑓82𝑏 𝐻6 → 𝑔 = 0𝑥1𝑓83𝑑9𝑎𝑏𝑓𝑏41𝑏𝑑6𝑏

0 0
𝐻3 → 𝑑 = 0𝑥𝑎54𝑓𝑓53𝑎5𝑓1𝑑36𝑓1 𝐻7 → ℎ = 0𝑥5𝑏𝑒0𝑐𝑑19137𝑒2179

Y de igual manera se inicializan las constantes 𝑘𝑖 que serían los primeros 64 bits de la

parte decimal de las raíces cúbicas de los 80 primeros números.

Paso 2: Pre procedimiento. A continuación, como nos indican Martino y Cilardo(2020),

el mensaje se rellena con un solo 1 seguido de tantos 0 bits como sea necesario para alcanzar
 20

una longitud congruente con 896 mod 1024 , para dejar los últimos 128 bits para codificar la

longitud original del mensaje. Esto implica que el límite de la longitud del mensaje que se va a

128
codificar se incrementa hasta 2 − 129 bits.

0 1 𝑁
Analizar el mensaje relleno en N bloques de mensajes 𝐵 , 𝐵 , …, 𝐵 donde el tamaño del

bloque es de 1024 bits.

Los pasos 3 y 4 son bucles de 80 iteraciones en cada bloque de 1024 bits.

Paso 3: Preparar la programación del mensaje

𝑖
𝐵 𝑡 , (0 ≤ 𝑡 ≤ 15)
𝑊𝑡 =
( ) (
σ1 𝑊𝑡−2 + 𝑊𝑡−7 + σ0 𝑊𝑡−15 + 𝑊𝑡−16 , ) (16≤ 𝑡 ≤80)

Donde:

19 61 6
σ1(𝑥) = 𝑅𝑂𝑇𝑅 (𝑥)⨁ 𝑅𝑂𝑇𝑅 (𝑥)⨁𝑆𝐻𝑅 (𝑥)

1 8 7
σ0(𝑥) = 𝑅𝑂𝑇𝑅 (𝑥)⨁ 𝑅𝑂𝑇𝑅 (𝑥)⨁𝑆𝐻𝑅 (𝑥)

Paso 4: Bucle principal de compresión. Chaves et al.(2016) proponen el siguiente

fragmento de algoritmo para el bucle de compresión(p. 86).

𝑇1 = ℎ + ∑ (𝑒) + 𝐶ℎ(𝑒, 𝑓, 𝑔) + 𝑘𝑡 + 𝑊𝑡
1

𝑇2 = ∑ (𝑎) + 𝑀𝑎𝑗(𝑎, 𝑏, 𝑐)
0

ℎ = 𝑔 ; 𝑔 = 𝑓 ; 𝑓 = 𝑒;
𝑒 = 𝑑 + 𝑇1;

𝑑 = 𝑐 ; 𝑐 = 𝑏 ; 𝑏 = 𝑎;
 21

𝑎 = 𝑇1 + 𝑇2

Donde:
𝐶ℎ(𝑥, 𝑦, 𝑧) = (𝑥∧𝑦)⨁(¬𝑥 ∧𝑧)

𝑀𝑎𝑗(𝑥, 𝑦, 𝑧) = (𝑥∧𝑦)⨁(𝑥 ∧𝑧)⨁(𝑦 ∧𝑧)

28 34 39
∑ (𝑥) = 𝑅𝑂𝑇𝑅 (𝑥)⨁ 𝑅𝑂𝑇𝑅 (𝑥)⨁𝑅𝑂𝑇𝑅 (𝑥)
0

14 18 41
∑ (𝑥) = 𝑅𝑂𝑇𝑅 (𝑥)⨁ 𝑅𝑂𝑇𝑅 (𝑥)⨁𝑅𝑂𝑇𝑅 (𝑥)
1

Paso 5: Inserción del trozo comprimido al valor hash actual. Suponiendo que se

calcula el i-ésimo valor hash intermedio, los valores de 𝐻0 a 𝐻7 son iterados y calculados

por un sumador.

𝑖 𝑖−1 𝑖 𝑖−1
𝐻0 = 𝑎 + 𝐻0 … 𝐻7 = ℎ + 𝐻7

Paso 6: Salida. Después de repetir los pasos anteriores N veces, el resultado de

resumen del mensaje es:

𝑁 𝑁 𝑁 𝑁 𝑁 𝑁 𝑁 𝑁
𝐻0 || 𝐻1 || 𝐻2 || 𝐻3 ||𝐻4 || 𝐻5 ||𝐻6 || 𝐻7

donde el símbolo || denota el operador de concatenación.

Simulación

Long (2019) realizó un estudio donde comparó el tiempo de ejecución; los experimentos

se realizaron en Windows 10 con Intel (R) Core (TM) CPU i5-6300HQ @ 2.30GHz 2.30GHz y

8.00GB RAM y sistema operativo de 64 bits. El funcionamiento del entorno utilizado para

codificar C++ en Visual Studio 2013 (p.5).

 22

Simulación del algoritmo HASH MD5

➢ Cadena de caracteres: “abc”

➢ Valor Hash: 900150983cd24fb0d6963f7d28e17f72

➢ Tiempo promedio de funcionamiento: 3.08556 ms NBET = 0.97227 bit/ms

Simulación del algoritmo SHA-1

➢ Cadena de caracteres: “abc”

➢ Valor Hash: a9993e364706816aba3e25717850c26c9cd0d89d

➢ Tiempo de ejecución promedio: 8.87031 ms NBET = 0.33821 bit/ms

Simulación del algoritmo SHA-512

➢ Cadena de caracteres: “abc”

➢ Valor Hash:

ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a8

36ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f

➢ Tiempo promedio de funcionamiento: 10.79296 ms NBET = 0.27796 bit/ms

Ejemplo de Encriptación SHA con C++ (SHA-1)

Código C++

#include <iostream>
#include <string>
#ifndef _TINY_SHA1_HPP_
#define _TINY_SHA1_HPP_
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <stdint.h>
namespace sha1{
class SHA1{
public:
typedef uint32_t digest32_t[5];
typedef uint8_t digest8_t[20];
inline static uint32_t LeftRotate(uint32_t value, size_t count) {
 23

return (value << count) ^ (value >> (32-count));

}
SHA1(){ reset(); }
virtual ~SHA1() {}
SHA1(const SHA1& s) { *this = s; }
const SHA1& operator = (const SHA1& s) {
memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t));
memcpy(m_block, s.m_block, 64);
m_blockByteIndex = s.m_blockByteIndex;
m_byteCount = s.m_byteCount;
return *this; }
SHA1& reset() {
m_digest[0] = 0x67452301; m_digest[1] = 0xEFCDAB89;
m_digest[2] = 0x98BADCFE; m_digest[3] = 0x10325476;
m_digest[4] = 0xC3D2E1F0; m_blockByteIndex = 0;
m_byteCount = 0;
return *this; }
SHA1& processByte(uint8_t octet) {
this->m_block[this->m_blockByteIndex++] = octet;
++this->m_byteCount;
if(m_blockByteIndex == 64) {
this->m_blockByteIndex = 0;
processBlock(); }
return *this; }
SHA1& processBlock(const void* const start, const void* const end){
const uint8_t* begin = static_cast<const uint8_t*>(start);
const uint8_t* finish = static_cast<const uint8_t*>(end);
while(begin != finish) {
processByte(*begin);
begin++;
} return *this; }
SHA1& processBytes(const void* const data, size_t len) {
const uint8_t* block = static_cast<const uint8_t*>(data);
processBlock(block, block + len);
return *this; }
const uint32_t* getDigest(digest32_t digest) {
size_t bitCount = this->m_byteCount * 8;
processByte(0x80);
if (this->m_blockByteIndex > 56) {
while (m_blockByteIndex != 0)
processByte(0);
while (m_blockByteIndex < 56)
processByte(0);
} else {
while (m_blockByteIndex < 56)
processByte(0);
}
processByte(0); processByte(0); processByte(0);
processByte(0);
processByte( static_cast<unsigned char>((bitCount>>24) & 0xFF));
processByte( static_cast<unsigned char>((bitCount>>16) & 0xFF));
processByte( static_cast<unsigned char>((bitCount>>8 ) & 0xFF));
processByte( static_cast<unsigned char>((bitCount) & 0xFF));
memcpy(digest, m_digest, 5 * sizeof(uint32_t));
 24

return digest; }
const uint8_t* getDigestBytes(digest8_t digest) {
digest32_t d32;
getDigest(d32);
size_t di = 0;
digest[di++] = ((d32[0] >> 24) & 0xFF);
digest[di++] = ((d32[0] >> 16) & 0xFF);
digest[di++] = ((d32[0] >> 8) & 0xFF);
digest[di++] = ((d32[0]) & 0xFF);
digest[di++] = ((d32[1] >> 24) & 0xFF);
digest[di++] = ((d32[1] >> 16) & 0xFF);
digest[di++] = ((d32[1] >> 8) & 0xFF);
digest[di++] = ((d32[1]) & 0xFF);
digest[di++] = ((d32[2] >> 24) & 0xFF);
digest[di++] = ((d32[2] >> 16) & 0xFF);
digest[di++] = ((d32[2] >> 8) & 0xFF);
digest[di++] = ((d32[2]) & 0xFF);
digest[di++] = ((d32[3] >> 24) & 0xFF);
digest[di++] = ((d32[3] >> 16) & 0xFF);
digest[di++] = ((d32[3] >> 8) & 0xFF);
digest[di++] = ((d32[3]) & 0xFF);
digest[di++] = ((d32[4] >> 24) & 0xFF);
digest[di++] = ((d32[4] >> 16) & 0xFF);
digest[di++] = ((d32[4] >> 8) & 0xFF);
digest[di++] = ((d32[4]) & 0xFF);
return digest; }
protected:
void processBlock() {
uint32_t w[80];
for (size_t i = 0; i < 16; i++) {
w[i] = (m_block[i*4 + 0] << 24);
w[i] |= (m_block[i*4 + 1] << 16);
w[i] |= (m_block[i*4 + 2] << 8);
w[i] |= (m_block[i*4 + 3]); }
for (size_t i = 16; i < 80; i++) {
w[i] = LeftRotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]),
1); }
uint32_t a = m_digest[0];uint32_t b = m_digest[1];
uint32_t c = m_digest[2];uint32_t d = m_digest[3];
uint32_t e = m_digest[4];
for (std::size_t i=0; i<80; ++i) {
uint32_t f = 0;
uint32_t k = 0;
if (i<20) {
f = (b & c) | (~b & d);
k = 0x5A827999; } else if (i<40) {
f = b ^ c ^ d;
k = 0x6ED9EBA1; } else if (i<60) {
f = (b & c) | (b & d) | (c & d);
k = 0x8F1BBCDC; } else {
f = b ^ c ^ d;
k = 0xCA62C1D6; }
uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i];
e = d; d = c;
 25

c = LeftRotate(b, 30); b = a;
a = temp; }

m_digest[0] += a; m_digest[1] += b;
m_digest[2] += c; m_digest[3] += d;
m_digest[4] += e; }
private:
digest32_t m_digest;
uint8_t m_block[64];
size_t m_blockByteIndex;
size_t m_byteCount;
};
}
#endif
void testSHA1(const std::string& val) {
sha1::SHA1 s;
[Link](val.c_str(), [Link]());
uint32_t digest[5];
[Link](digest);
char tmp[48];
snprintf(tmp, 45, "%08x %08x %08x %08x %08x", digest[0], digest[1], digest[2],
digest[3], digest[4]);
std::cout<<"Calculated : (\""<<val<<"\") = "<<tmp<<std::endl;
}
int main(int argc, char **argv) {
testSHA1("cor"); //Cabe recalcar que no se deben incluir las tildes y la 'ñ'
testSHA1("Este es un mensaje predeterminado para poder mostrar una cadena
super hiper mega archi larga :) Muchas Gracias");
testSHA1("Fiorela");
testSHA1("fiorela");
testSHA1("a");
testSHA1(" ");
testSHA1("DNI14./$");return 0
 26

Resultados

El primer y segundo resultado nos demuestran que el tamaño del mensaje que se ingresa

a la función Hash no es relevante con respecto al tamaño de salida, este siempre saldrá con una

longitud de 160 bits.

En la tercera y cuarta cadena, podemos ver como un cambio mínimo puede llegar a un

mensaje de salida muy diferente.

Finalmente, podemos ver que dentro de la cadena puede ingresar cualquier caracter, inclusive el

espacio. Cabe resaltar que no se deben incluir tildes ni la letra “ñ”.

 27

Conclusiones

El uso de la firma digital conlleva a una nueva forma de trasmisión de mensajes que garantiza la

integridad y la autenticación de los mismos. El proceso es más rápido y más seguro en

comparación con la firma manuscrita y su uso actualmente es cada vez mayor. Para comprobar la

validez de una firma digital, es necesario que esté seguro de que la clave pública que utiliza para

verificarla. Esta verificación recae en el certificado digital firmado por una CA. Por lo tanto, los

certificados digitales y la CA son la pieza clave.

Los tokens, como dispositivos utilizados en el almacenamiento de claves, brindan un medio

seguro que complementa los beneficios de la firma digital, además de cumplir un papel

importante en el proceso de encriptamiento. Para poder generar las claves requeridas por el

usuario existen algoritmos que cumplen dicha función y la velocidad que emplean es un aspecto

importante. En términos de velocidad, el algoritmo MD5 es el más veloz entre los 3 algoritmos

HASH presentados, ya que es mucho más simple. Por otra parte, el algoritmo SHA-2 es el más

seguro de los 3 presentados.

1.
 28

Referencias

Aguilar Alcarráz, G. B. (2016). Implementación de un modelo simplificado de firma digital

basado en la tecnología PKI y la invocación por protocolos caso de estudio:

Municipalidad de Miraflores.

Algredo-Badillo, I., Cumplido-Parra, R. A., & Feregrino-Uribe, C. (2004). Desarrollo de un

Módulo MD5 para un Sistema Criptográfico Reconfigurable en un FPGA. In Por

aparecer en International Conference on Reconfigurable Computing and FPGAs,

ReConFig04, México.

Algredo-Badillo, I., Cumplido-Parra, R., & Feregrino-Uribe, C. (s.f.) Rondas Parcialmente

Desenrolladas para Implementaciones a 1 Gbps en FPGA de los Algoritmos SHA-1 y

MD5.

Alvarez Villalva, C. J., Idrobo Borja, D. M., & Mendoza Macias, O. (2005). Creación de una

empresa proveedora de certificados de firma digital para operadores de comercio exterior

en el Ecuador (Bachelor's thesis).

Cardador Cabello, A. L. (2014). Desarrollo de aplicaciones web distribuidas. Málaga: IC

Editorial.

Chaves, R., Sousa, L., Sklavos, N., Fournaris, A. P., Kalogeridou, G., Kitsos, P., & Sheikh, F.

(2016). Secure hashing: SHA-1, SHA-2, and SHA-3. Circuits and Systems for Security

and Privacy; Taylor & Francis Group: Abingdon, UK, 105-132.

 29

De la Motta Paez, D. E., & Vela Berrocal, L. H. (2008). Sistema de protección de archivos de

constitución de empresas haciendo uso de la tecnología de firma digital.

Díaz Orueta, G., Alzórriz Armendáriz, I., Sancrsitóbal Ruiz, E., & Castro Gil, M. (2014).

Proceso y herramientas para la seguridad de redes. Universidad Nacional de Educación

a Distancia. Madrid: UNED.

Escalona, S. B., & Inclán, L. V. (2012). Funciones resúmenes o hash. Revista Telemática, 10(1).

García Rojas, W. A. (2008). Implementación de firma digital en una plataforma de comercio

electrónico.

García, F. Y. H. (2018). Análisis de la firma digital con base en la infraestructura de clave

pública. Hamut´ ay, 5(2), 95-105.

Ghoshal, S., Bandyopadhyay, P., Roy, S., & Baneree, M. (2020). A journey from MD5 to SHA-3

doi:10.1007/978-981-15-1624-5_11.

Gómez, L. S. M.(s.f.) MD5 para la Certificación de Copias.

Gonzáles Manzano, L., María De Fuentes, J., & Romero de Tejada, G. (2014). Sistemas seguros

de acceso y transmisión de datos. IFCT0109. Málaga: IC Editorial.

Lin, C. -., Liu, J. -., Chen, J. I. -., & Chu, T. -. (2019). On the performance of cracking hash

function SHA-1 using cloud and GPU computing. Wireless Personal Communications,

109(1), 491-504. doi:10.1007/s11277-019-06575-9.

 30

Long, S. (2019). A comparative analysis of the application of hashing encryption algorithms for

MD5, SHA-1, and SHA-512. Paper presented at the Journal of Physics: Conference

Series, , 1314(1) doi:10.1088/1742-6596/1314/1/012210.

Martino, R., & Cilardo, A. (2020). SHA-2 acceleration meeting the needs of emerging

applications: A comparative survey. IEEE Access, 8, 28415-28436.

doi:10.1109/ACCESS.2020.2972265

Mohit, P., & Biswas, G. P. (2017). Modification of traditional RSA into symmetric-RSA

cryptosystems. International Journal of Business Data Communications and Networking,

13(1), 66-73. 10.4018/IJBDCN.2017010106

Oppliger, R. (2014). Secure Messaging on the Internet. Boston: Artech House.

Reyes González, E. J., & Quintero Peña, J. G. (2006). Firma digital basada en redes(Lattice).

Revista Científica, (8), 53 - 64. [Link]

Rezaeighaleh, H., Laurens, R., & Zou, C. C. (2018). Secure smart card signing with time-based

digital signature. Paper presented at the 2018 International Conference on Computing,

Networking and Communications, 182-187. 10.1109/ICCNC.2018.8390321.

Soriano, M. (2014). Seguridad en redes y seguridad de la información. Obtenido de

[Link] cvut. cz/project/download/C2ES/Seguridad_de_Red_e_Informacion. pdf.