Este documento describe dos métodos de encriptación: EncryptionString y ChrTran. EncryptionString encripta el texto sumando el código ASCII de cada carácter con una clave. ChrTran es más complejo, transponiendo cada carácter a otra posición usando dos claves aleatorias. También describe el protocolo Diffie-Hellman para establecer una clave compartida de forma segura entre dos partes a través de un canal inseguro.

1. ESCUELA POLITECNICA DEL EJERCITO
Nombre: David Sulca
Curso: 1ª Comercial
Fecha: 2009-11-10
1._ Metodos de encriptación.
Clave publica._
Modelo EncryptionString._
EncryptionString, es un clásico sistema el cual toma el mensaje y una clave del usuario, y a través de una
combinación de estos dos parámetros se produce una cadena codificada. Mantengo la explicación original
del método:
Texto a codificar: ENCRYPTION
Caracteres del Texto: E N C R Y P T I O N
Códigos ASCII: 69 78 67 82 89 80 84 73 79 78
Contraseña KEY: K E Y K E Y K E Y K
Caracteres de KEY: 75 69 89 75 69 89 75 69 89 75
Suma de Códigos ASCII: 144 147 156 157 158 169 159 142 168 153
En caracteres: ﾐ “ œ ﾝ ? © Ÿ ? ¨ ™
Texto codificado: 1“œ?©Ÿ?¨™
El modo para usar la función EncryptionString es el siguiente:
'//Codifica
TextoCodificado = EncryptString(TextoOriginal, Contraseña, ENCRYPT)
'//Decodifica
TextoOriginal = EncryptString(TextoCodificado, Contraseña, DECRYPT)
La ventaja de esta técnica es que es muy flexible de usar e intuitiva. Sin tener la máxima seguridad, es
muy segura. Escribir un programa para encriptar archivos resulta bastante simple por aquello de la
contraseña. No ocurre lo mismo con el siguiente procedimiento: ChrTran.
El código de EncryptionString es el siguiente:
DefInt A-Z
Option Explicit
'//For Action parameter in EncryptString
Public Const ENCRYPT = 1, DECRYPT = 2
'---------------------------------------------------------------------
' EncryptString
' Modificado por Harvey T.
'---------------------------------------------------------------------
Public Function EncryptString( _
UserKey As String, Text As String, Action As Single _
) As String
Dim UserKeyX As String
Dim Temp As Integer
Dim Times As Integer
Dim i As Integer
Dim j As Integer

2. Dim n As Integer
Dim rtn As String
'//Get UserKey characters
n = Len(UserKey)
ReDim UserKeyASCIIS(1 To n)
For i = 1 To n
UserKeyASCIIS(i) = Asc(Mid$(UserKey, i, 1))
Next
'//Get Text characters
ReDim TextASCIIS(Len(Text)) As Integer
For i = 1 To Len(Text)
TextASCIIS(i) = Asc(Mid$(Text, i, 1))
Next
'//Encryption/Decryption
If Action = ENCRYPT Then
For i = 1 To Len(Text)
j = IIf(j + 1 >= n, 1, j + 1)
Temp = TextASCIIS(i) + UserKeyASCIIS(j)
If Temp > 255 Then
Temp = Temp - 255
End If
rtn = rtn + Chr$(Temp)
Next
ElseIf Action = DECRYPT Then
For i = 1 To Len(Text)
j = IIf(j + 1 >= n, 1, j + 1)
Temp = TextASCIIS(i) - UserKeyASCIIS(j)
If Temp < 0 Then
Temp = Temp + 255
End If
rtn = rtn + Chr$(Temp)
Next
End If
'//Return
EncryptString = rtn
End Function
Modelo ChrTran._
ChrTran es violentamente complicado de violar, de hecho imposible. Virtualmente las probabilidades de
descifrar un mensaje son del orden de 255! (255 factorial), un numero sin fin en la práctica (por ejemplo
las calculadoras comunes soportan solo hasta 69!).
Tengo que confesar que tuve que reescribir ChrTran porque presentaba errores de programación y mucho
código para optimizar, el resultado es sorprendente. Ni que decir que no tenía en cuenta que en español
usamos tildes y eñes.
Como su abreviación lo dice ChrTran transpone caracteres, usa dos claves de 255 caracteres (la carta
ASCII) y produce un texto codificado de origen aleatorio. Toma cada carácter del texto, encuentra su
posición en la primera clave, e intercambia este carácter por el carácter en la misma posición de la
segunda clave. Es complicado de asimilar.

3. Lo más difícil de ChrTran es el manejo de las claves. La primera clave (la sarta de búsqueda) podría ser
publica (mejor debiera decir debe ser publica). Mientras que la segunda clave es una sarta aleatoria de la
carta ASCII.
El modo de manejar ChrTran es el siguiente:
ClaveAleatoria = RandomChart()
'// Se podría usar la sarta de búsqueda, ClaveDeBúsqueda, como
'// otra cadena aleatoria con ClaveDeBúsqueda = RandomChart()
'// aqui se mantiene un nivel de Encriptación flexible, más no
'// inseguro, al hacer ClaveDeBúsqueda como la secuencia 0 a 255
'// de la carta ASCII:
For i = 0 To 255
ClaveDeBúsqueda = ClaveDeBúsqueda + Chr$(i)
Next
'//Codifica
TextoCodificado = ChrTran(TextoOriginal, ClaveDeBúsqueda,
ClaveAleatoria)
'//Decodifica
TextoOriginal= ChrTran(TextoCodificado, ClaveAleatoria,
ClaveDeBúsqueda)
En la primera línea se usa RandonChart, la cual es una función que retorna la carta ASCII en un orden
aleatorio.
Como posiblemente se deduce, usar ChrTran para escribir un programa que trabaje encriptación,
representa una labor bastante especializada, pero por supuesto nada del otro mundo.
El código de ChrTran es el siguiente:
DefInt A-Z
Option Explicit
'//---------------------------------------------
'// Return a random string of ASCII Chart.
'// Used by ChrTran. By Harvey T.
'//---------------------------------------------
Public Function RandomChart() As String
Dim Char As String
Dim RndStr As String
Dim n As Integer
Randomize Timer
Do
Char = Chr$(Int(Rnd * 256))
If InStr(RndStr, Char) = 0 Then
n = n + 1
RndStr = RndStr + Char
End If
Loop Until n = 256
RandomChart = RndStr
End Function
'---------------------------------------------------------------------
' ChrTran
' Optimizing by Harvey T.

4. '---------------------------------------------------------------------
Public Function ChrTran(Text As String, SStr As String, EStr As
String) As String
Dim i As Integer
Dim rtn As String
For i = 1 To Len(Text)
rtn = rtn + Mid$(EStr, InStr(SStr, Mid$(Text, i, 1)), 1)
Next
ChrTran = rtn
End Function
Diffie-Hellman._
El protocolo Diffie-Hellman[1] (debido a Whitfield Diffie y Martin Hellman) permite el
intercambio secreto de claves entre dos partes que no han tenido contacto previo,
utilizando un canal inseguro, y de manera anónima (no autenticada).
Se emplea generalmente como medio para acordar claves simétricas que serán
empleadas para el cifrado de una sesión.
Siendo no autenticado, sin embargo provee las bases para varios protocolos
autenticados.
Su seguridad radica en la extrema dificultad (conjeturada, no demostrada) de calcular
logaritmos discretos en un campo finito.
Versión básica
Diffie-Hellman
Para dos partes A y B que intentan establecer una clave secreta y un adversario E, la
versión básica es como sigue:
• Se establecen un primo p y un generador ([2] ). Estos son públicos,
conocidos no sólo por las partes A y B sino también por el adversario E.
• A escoge al azar, calcula X = gxmod p, y envía X a B

5. • B escoge al azar, calcula Y = gymod p, y envía Y a A
Nótese que Xy = (gx)y = gxy = (gy)x = Yx, con todas las operaciones en el grupo .
Llamemos K a esta cantidad común: el hecho destacable es que ambas partes pueden
calcularla, y por lo tanto obtener una clave compartida.
Un adversario E que poseyera p, g, X e Y, podría calcular el secreto compartido si
tuviera también uno de los valores privados (x o y) o lograse invertir la función. Pero
calcular x dado X es el problema del logaritmo discreto en , un problema que se cree
intratable computacionalmente. El mismo protocolo, y otros basados en este, pueden
llevarse a cabo en cualquier grupo en que a la vez la exponenciación sea simple y el
logaritmo discreto difícil, como el grupo multiplicativo análogo de los campos de
Galois o el grupo de puntos definidos por una curva elíptica sobre un campo finito.
Sin embargo, el protocolo es sensible a ataques activos del tipo "hombre en el medio"
(mitm, man-in-the-middle). Si la comunicación es interceptada por un tercero, éste se
puede hacer pasar por el emisor cara al destinatario y viceversa, ya que no se dispone de
ningún mecanismo para validar la identidad de los participantes en la comunicación.
Así, el "hombre en el medio" podría acordar una clave con cada participante y
retransmitir los datos entre ellos, escuchando la conversación en ambos sentidos.
Ejemplo del protocolo
1. A y B acuerdan usar el
B número primo p=23 y la
A base g=5.
Calc Sec 2. A elige un número secreto
Sec Calc
a=6, luego envía a B (ga
p, g mod p)
p, g
o 56 mod 23 = 8.
b
a 3. B elige un número secreto
… b=15, luego envía a A (gb
ga mod p)
mod p gb o 515 mod 23 = 19.
mod 4. A calcula (gb mod p)a mod
…
p p
(gb mod o 196 mod 23 = 2.
(ga mod 5. B calcula (ga mod p)b mod
p)a mod
p)b mod p
p
p
= o 815 mod 23 = 2.
Valores mucho más grandes de a,b y p se necesitarían para hacer este ejemplo seguro.
Dado que es muy sencillo probar todos los valores posibles de gab mod 23 (habrá, como
máximo, 22 valores, inclusive si a y b son números grandes). Si p fuera un primo de
más de 300 dígitos, y a y b fueran por lo menos de 100 dígitos, entonces hasta el mejor
algoritmo para encontrar a dado g, p, y ga mod p tomaría más tiempo que la vida del
universo para resolverse. g no necesita ser grande, y en la práctica es usualmente 2 o 5.

6. Clave privada._
Triple DES._
En criptografía el Triple DES se llama al algoritmo que hace triple cifrado del DES.
También es conocido como TDES o 3DES, fue desarrollado por IBM en 1978.
Algoritmo
No llega a ser un cifrado múltiple, porque no son independientes todas las subclases.
Este hecho se basa en que DES tiene la característica matemática de no ser un grupo, lo
que implica que si se cifra el mismo bloque dos veces con dos claves diferentes se
aumenta el tamaño efectivo de la clave.
La variante más simple del Triple DES funciona de la siguiente manera:
Donde M es el mensaje a cifrar y k1, k2 y k3 las respectivas claves DES. En la variante
3TDES las tres claves son diferentes; en la variante 2TDES, la primera y tercera clave
son iguales.
Seguridad
Cuando se descubrió que una clave de 56 bits no era suficiente para evitar un ataque de
fuerza bruta, TDES fue elegido como forma de agrandar el largo de la clave sin
necesidad de cambiar de algoritmo de cifrado. Este método de cifrado es inmune al
ataque por encuentro a medio camino, doblando la longitud efectiva de la clave (112
bits), pero en cambio es preciso triplicar el número de operaciones de cifrado, haciendo
este método de cifrado muchísimo más seguro que el DES. Por tanto, la longitud de la
clave usada será de 192 bits, aunque como se ha dicho su eficacia solo sea de 112 bits.

7. Blowfish._
En criptografía, Blowfish es un codificador de bloques simétricos, diseñado por Bruce
Schneier en 1993 e incluido en un gran número de conjuntos de codificadores y
productos de cifrado. Mientras que ningún analizador de cifrados de Blowfish efectivo
ha sido encontrado hoy en día, se ha dado más atención de la decodificación de bloques
con bloques más grandes, como AES y Twofish.
Schneier diseñó Blowfish como un algoritmo de uso general, que intentaba reemplazar
al antiguo DES y evitar los problemas asociados con otros algoritmos. Al mismo
tiempo, muchos otros diseños eran propiedad privada, patentados o los guardaba el
gobierno. Schneier declaró “Blowfish no tiene patente, y así se quedará en los demás
continentes. El algoritmo está a disposición del público, y puede ser usado libremente
por cualquiera”.
El Algoritmo
Diagrama de Blowfish
Blowfish usa bloques de 64 bits y claves que van desde los 32 bits hasta 448 bits. Es un
codificador de 16 rondas Feistel y usa llaves que dependen de las Cajas-S. Tiene una
estructura similar a CAST-128, el cual usa Cajas-S fijas.
El diagrama muestra la acción de Blowfish. Cada línea representa 32 bits. El algoritmo
guarda 2 arrays de subclaves: El array P de 18 entradas y 4 cajas-S de 256 entradas. Una
entrada del array P es usada cada ronda, después de la ronda final, a cada mitad del
bloque de datos se le aplica un XOR con uno de las 2 entradas del array P que no han
sido utilizadas.

8. La función divide las entrada de 32 bits en 4 bloques de 8 bits, y usa los bloques como
entradas para las cajas-S. Las salidas deben estar en módulo 232 y se les aplica un XOR
para producir la salida final de 32 bits.
Diagrama de la función F de Blowfish
Debido a que Blowfish está en la red Feistel, puede ser invertido aplicando un XOR
entre P17 y P18 al bloque texto codificado, y así sucesivamente se usan las P-entradas en
orden reversivo.
La generación de claves comienza inicializando los P-arrays y las cajas-S con los
valores derivados de los dígitos hexadecimales de pi, los cuales no contienen patrones
obvios. A la clave secreta se le aplica un XOR con las P-entradas en orden (ciclando la
clave si es necesario). Un bloque de 64 bits de puros ceros es cifrado con el algoritmo
como se indica. El texto codificado resultante reemplaza a P1 y P2. Entonces el texto
codificado es cifrado de nuevo con la nuevas subclaves, P3 y P4 son reemplazados por el
nuevo texto codificado. Esto continúa, reemplazando todas las entradas del P-array y
todas las entradas de las cajas-S. En total, el algoritmo de cifrado Blowfish correrá 521
veces para generar todas las subclaves, cerca de 4KB de datos son procesados.
International Data Encryption Algorithm._
En criptografía, International Data Encryption Algorithm o IDEA (del inglés,
Algoritmo Internacional de Cifrado de Datos) es un cifrador por bloques diseñado por
Xuejia Lai (?) y James L. Massey de la Escuela Politécnica Federal de Zúrich y descrito
por primera vez en 1991. Fue un algoritmo propuesto como reemplazo del DES (Data
Encryption Standard) . IDEA fue una revisión menor de PES (Proposed Encryption
Standard, del inglés Estándar de Cifrado Propuesto), un algoritmo de cifrado anterior.
Originalmente IDEA había sido llamado IPES (Improved PES, del inglés PES
Mejorado). IDEA fue diseñado en contrato con la Fundación Hasler, la cual se hizo
parte de Ascom-Tech AG. IDEA es libre para uso no comercial, aunque fue patentado y
sus patentes se vencerán en 2010 y 2011. El nombre "IDEA" es una marca registrada y
está licenciado mundialmente por MediaCrypt.
IDEA fue utilizado como el cifrador simétrico en las primeras versiones de PGP (PGP
v2.0) y se lo incorporó luego de que el cifrador original usado en la v1.0 ("Bass-O-
Matic") se demostró insegura. Es un algoritmo óptimo en OpenPGP.

9. Funcionamiento
IDEA opera con bloques de 64 bits usando una clave de 128 bits y consiste de ocho
transformaciones idénticas (cada una llamada un ronda) y una transformación de salida
(llamada media ronda). El proceso para cifrar y descifrar es similar. Gran parte de la
seguridad de IDEA deriva del intercalado de operaciones de distintos grupos — adición
y multiplicación modular y O-exclusivo (XOR) bit a bit — que son algebraicamente
"incompatibles" en cierta forma.
IDEA utiliza tres operaciones en su proceso con las cuales logra la confusión, se
realizan con grupos de 16 bits y son:
• Operación O-exclusiva (XOR) bit a bit (indicada con un ⊕ azul)
• Suma módulo 216 (indicada con un verde)
• Multiplicación módulo 216+1, donde la palabra nula (0x0000) se interpreta como
216 (indicada con un rojo)
(216 = 65536; 216+1 = 65537, que es primo)
Después de realizar 8 rondas completas se realiza la mitad, obteniendo el resultado en
este paso de la ronda:
Este algoritmo presenta, a primera vista, diferencias notables con el DES, que lo hacen
más atractivo:
• El espacio de claves es mucho más grande: 2128 ≈ 3.4 x 1038
• Todas las operaciones son algebraicas
• No hay operaciones a nivel bit, facilitando su programación en alto nivel
• Es más eficiente que los algoritmos de tipo Feistel, porque a cada vuelta se
modifican todos los bits de bloque y no solamente la mitad.
• Se pueden utilizar todos los modos de operación definidos para el DES
Seguridad
En primer lugar, el ataque por fuerza bruta resulta impracticable, ya que sería necesario
probar 1038 claves, cantidad imposible de manejar con los medios informáticos actuales.
Los diseñadores analizaron IDEA para medir su fortaleza frente al criptoanálisis
diferencial y concluyeron que es inmune bajo ciertos supuestos. No se han reportado
debilidades frente criptoanálisis lineal o algebraico. Se han encontrado algunas claves
débiles, las cuales en la práctica son poco usadas siendo necesario evitarlas
explícitamente. Es considerado por muchos como uno de los cifrados en bloque más
seguros que existen.