Hardening AES256 – CrypText

Castellano.

Últimamente no he escrito mucho, he estado ocupado con otros proyectos, ahora llega el momento de fusionar ambos.

Estoy desarrollando una aplicación de cifrado seudo-paranoico. Se basa en el estándar AES256 al cual le añadimos dos capas para evitar algunos ataques.

El programa esta totalmente escrito en Haskell ayudándome de su entorno de desarrollo Stack y se encuentra en Alpha 0.1.3. Ya estoy implementando la ultima capa de cifrado simétrico.

Hasta la versión 1 estará solo disponible para cifrado de texto con clave de 512 bites o superior y orientado, a poder usarse en cualquier red social, servicio de mensajería o email. También cifrara mediante curvas elípticas para el envío de claves.

Los paquetes que estoy desarrollando están orientados a poderse usar también para el cifrado de archivos ya que están diseñadas para ByteString, pero esto no sera hasta la versión 2.

En versiones posteriores también se podría implementar un servicio de mensajería basado en el anonimato, una vez que añada conexión a base de datos. Quizá en la version 3

La aplicación se llama CrypText y se encuentra alojada en mi repositorio GitLab. Y se distribuye bajo licencia BSD 3-clause traducido al castellano Licencia Publica de Libre Uso.

Aquellos que queráis colaborar, probarla o trastear estáis invitados.

English.

Lately I have not written much, I’ve been busy with other projects, now it’s time to merge both.
I am developing a pseudo-paranoid encryption application. It is based on the AES256 standard to which we add two layers to avoid some attacks.


The program is completely written in Haskell, helping me with its Stack development environment and it is in Alpha 0.1.3. I am already implementing the last layer of symmetric encryption.


Until version 1 will only be available for text encryption with a 512-bit key or higher and oriented, to be used in any social network, messaging service or email. It will also encrypt using elliptical curves for sending keys.


The packages that I am developing are oriented to be able to be used also for the encryption of files since they are designed for ByteString, but this will not be until the version 2.


In later versions you could also implement a messaging service based on anonymity, once you add a database connection. Maybe in version 3.


The application is called CrypText and is hosted in my repository GitLab. It is distributed under a BSD 3-clause license.


Those who want to collaborate, test or …. are invited.

Haskell. Veni Vidi Vici

Esta segunda entrada de programación en Haskell veremos un ejemplo de cifrado Cesar que nos permitirá practicar con la definición de funciones.

Para ponernos en situación veremos que es el cifrado Cesar, y en nuestro caso, con el fin de practicar con la definición de funciones, usaremos el alfabeto latín antiguo, el cual convivió con este cifrado en los años del Circo Romano, los acueductos…

Latín Antiguo.

El alfabeto que usaban en torno al año cero de la era cristiana, en el antiguo imperio romano era el latín antiguo y difería del alfabeto actual de 27 letras si incluimos la “ñ

  • En la Roma Antigua solo teníamos mayúsculas y las letras J,U,Ñ,W no estaban aún en el alfabeto.
  • La J fue I y la U fue V ( JESUS era IESVS ) y no llegan como tales, hasta el siglo XVIII, aunque coexistieron desde el origen ligadas a las letras I y V.
  • X e Y entraron en siglo 2 a.C. por la conquista del Imperio Griego.
  • Las minúsculas llegaron en la Edad Media.
  • La Ñ aparece como sustitución del dígrafo “NN” al final de la Edad Media en algunos alfabetos derivados del latín como el Castellano.
  • W entra en el siglo XIII por influecia de las lenguas germánicas.

Resumiendo nos queda un alfabeto de 23 letras (Sin J,U,Ñ,W) ABCDEFGHIKLMNOPQRSTVYZ

Cifrado Cesar.

El cifrado César,es una de las técnicas de cifrado más simples y más usadas. Es un tipo de cifrado por sustitución en el que una letra en el texto original es reemplazada por otra letra que se encuentra un número fijo de posiciones más adelante en el alfabeto. Por ejemplo, con un desplazamiento de 3, la A sería sustituida por la D (situada 3 lugares a la derecha de la A), la B sería reemplazada por la E, etc. Este método debe su nombre a Julio Cesar, que lo usaba para comunicarse con sus generales. Texto obtenido de la Wikipedia

Cifrado Cesar

Programa en Haskell.

Adaptaremos nuestro programa de cifrado Cesar al alfabeto latín antiguo. Nos fijaremos en la definición de la función ya que es lo más significativo del programa.

antiguas :: Int -> Char -> Char
antiguas n c
| elem c [‘A’..’I’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n ) 23)
| elem c [‘J’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-1 ) 23)
| elem c [‘K’..’T’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-1 ) 23)
| elem c [‘U’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-1 ) 23)
| elem c [‘V’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-2 ) 23)
| elem c [‘X’..’Z’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-3) 23)
| elem c [‘ ‘] = ‘ ‘
|otherwise = ‘*’

— Cifrado Cesar latín antiguo versión modulo 23 con 3 desplazamientos.

— Copyright (C) 2019 Vicente Parra Hurtado – NukeBull — Licencia GPL 3


import Data.Char

— Creamos el alfabeto Latín Antiguo

alfabeto :: [Char]
alfabeto = [‘A’..’I’]++[‘K’..’T’]++[‘V’]++[‘X’..’Z’]

— Implementando C. Cesar para cada letra
antiguas :: Int -> Char -> Char
antiguas n c
| elem c [‘A’..’I’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n ) 23)
| elem c [‘J’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-1 ) 23)
| elem c [‘K’..’T’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-1 ) 23)
| elem c [‘U’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-1 ) 23)
| elem c [‘V’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-2 ) 23)
| elem c [‘X’..’Z’] = alfabeto !! (mod ( (ord c) – (ord ‘A’) + n-3) 23)
| elem c [‘ ‘] = ‘ ‘
|otherwise = ‘*’

— Implementamos para String.

cesar :: Int -> String -> String
cesar n xs = [antiguas n x | x <- xs]

main = do

— Mostramos el Alfabeto Latin Antiguo.

putStrLn “Alfabeto latín antiguo”
putStrLn ( show ( alfabeto))

— Pedimos el texto a cifrar.

putStrLn “Introduce el texto a cifrar (Los caracteres que no existían en el latín antiguo se transformaran en *) “
line <- getLine

— Ciframos y deciframos n=3 y n=-3
— El cifrado original cesar es de 3 desplazamientos.

let texto = cesar 3 line
let textoDes = cesar (-3) texto
putStrLn (“Cifro hacía la derecha moviendo 3 posiciones”)
putStrLn ( show ( texto))
putStrLn (“Descifro hacía la izquierda moviendo 3 posiciones corrigiendo J y U “)
putStrLn ( show ( textoDes))

Ejecutamos.

runhaskell CesarAntiguo.hs
Alfabeto latín antiguo
“ABCDEFGHIKLMNOPQRSTVXYZ”
Introduce el texto a cifrar (Los caracteres que no existían en el latín antiguo se transformaran en *)
JULIO CESAR VINI VIDI VICI
Cifro hacía la derecha moviendo 3 posiciones
“MZOMR FHXDV ZMQM ZMGM ZMFM”
Descifro hacía la izquierda moviendo 3 posiciones corrigiendo J y U
“IVLIO CESAR VINI VIDI VICI”

Haskell, ¿donde esta for?.

Vamos a ir desarrollando pequeños programas en Haskell, para que podáis aprender conmigo a programar en este lenguaje. Nos servirá para aprender juntos y motivarnos a seguir escribiendo código.

Hoy vamos a crear un ejemplo básico pero instructivo, crearemos un programa para generar números primos, pero para los que vengáis de otros sistemas echareis de menos algo que siempre habéis usado, el muy conocido “for”, tan usado en otros lenguajes.

¿Deberiamos tener for en haskell?

Si vienes de otros lenguajes, la primera piensas que algo pasa, que no puede ser ¿como no puede haber for aquí? La respuesta es sencilla, por que no lo necesitamos, la programación funcional nos da unas herramientas muy potentes que nos harán olvidar a nuestro querido for.

Los que tengáis una base de matemáticas importante estaréis acostumbrados a este tipo de expresiones.

mathrm{mathsf{mathrm{S={2cdot xleft|: xinmathbb{N},: xleq10right.}}}}

En haskell gracias a las listas intencionales podemos definir conjuntos de una forma similar. [x*2 | x <- [1..10]]. Este ejemplo ha sido sacado de una de las mejores guías de Haskell en castellano: http://aprendehaskell.es/

Programar sin for.

El programa de ejemplo nos permitirá calcular los números primos entre 1 y otro que nosotros definamos.

Un número es primo cuando solamente es divisible por la unidad y por el mismo. 17 seria primo. 12 no lo seria, es divisible por 1,2,3,4 y 6.

http://www.nukebull.com
— El código genera todos los números primos entre el 1 y n

— Definimos cuantos divisores tiene un número, exceptuando el numero 1 y el mismo, mediante la función mod (modulo entero)

divisores :: Int -> [Int]
divisores y = [x | x <- [2..y-1], mod y x == 0]

— Es la función nos muestra todos los números entre 1 y n que cumplen la condición de no tener divisores (excepto 1 y n).

numerosprimos :: Int -> [Int]
numerosprimos y = [x | x <- [1..y], (divisores x)== []]

— Pediremos un numero n por terminal mediante getLine

main = do
putStrLn “¿Hasta qué número desea buscar?”
n <- getLine
let num = read(n)

— Mostramos por pantalla nuestros resultados.


putStrLn “Aquí los tiene “
putStrLn (show(numerosprimos num))

Lo guardamos como NumerosPrimos.hs y ejecutamos.

runhaskell NumerosPrimos.hs
¿Hasta qué número desea buscar?
80
Aquí los tiene
[1,2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79]

Como podemos apreciar no hemos usado for, debemos aprender a enfrentarnos a los problemas de forma funcional.

Visual Studio Code para Haskell – (Arch Linux)

Hoy muestro uno de los mejores editores para programar en haskell que he probado.

Es un viejo conocido que recientemente libero Microsorft. Visual Studio Code.

Como soy usuario de Antergos Linux,  os mostrare la instalación de este editor y de su extensión para haskell, en distribuciones basadas en Arch Linux.

Os dejo un vídeo para que os animéis a instalarlo, es muy sencillo y rápido. para los que uséis otro lenguaje de programación como Pythom el procedimiento es el mismo.

Para los que tengáis otras distros o S.O. os aconsejo utilizar Visual Studio Code para haskell.

 

Enlace de VSC.

Visual Studio Code

Enlace de Antergos Linux.

Antergos Linux

Pantallas 18:9, lo que no te quieren contar.

Esta entrada esta enfocada al hardware y como nos venden pantallas mas pequeñas como si fuesen más grandes. El paso del estándar para pantallas del móvil 16:9 al 18:9 genera mas beneficios a los fabricantes que a los usuarios. La medida de las pantallas de los teléfonos móviles se define comercialmente, como medida de la diagonal en pulgadas,
Nos venden una pantalla enorme en diagonal pero no nos dicen que tienen menor superficie para la misma diagonal que el formato anterior..
Aparte de la ergonomía pocas son sus ventajas. Veremos y calcularemos (exactamente con la ayuda de un programa de calculo creado en haskell que podréis copiaros),  cuanto perdemos cuando vemos videos o fotografías. Porque todo eso no te lo cuentan.

 

En la imagen muestra como el formato alargado 18:9 no usa toda la pantalla para ver películas o youtube. En el formato 16:9 las pantallas utilizan toda la superficie optimizando así nuestro smartphone

Teléfono 18:8 de 6 Pulgadas

 

Teléfono 16:9 de 6 Pulgadas

 

En las posteriores tabla se muestra para ambos formatos:

  1. Las pulgadas de la pantalla.
  2. Cuantas pulgadas de pantalla vemos reproduciendo películas sin cortarlas.
  3. Cuantas pulgadas de pantalla vemos visualizando una fotografía a tamaño completo.
  4. El área total de la pantalla en cm².
  5. Que móvil tendríamos que comprar en el otro formato para tener la misma superficie de pantalla.
  6. En la última tabla muestra que diagonal debe tener el móvil para ver una película exactamente igual en cada formato
  7. Las podéis descargar si queréis desde mii Google Drive: Descargar Tablas.

 

Ejemplo para pantalla de 6 pulgadas

En las tablas vemos como una pantalla 18:9 de 6 pulgadas se convierte en una de 5.4 pulgadas cuando ve películas y en una de 4.8 cuando ve imágenes.

Sin embargo una pantalla 16:9 de 6 pulgadas sigue siendo de 6 pulgadas cuando ve películas y es de 5.3 viendo imágenes.

Con  un teléfono de 6 pulgadas en 16:9 vemos la película exactamente igual que con uno de 6.577 pulgadas en 18:9

Conclusiones:

  • Perderemos entre 0.5 y 0.7 pulgadas al ver un video con el formato alargado para la misma diagonal de pantalla.
  • Perderemos entre 0.4 y 0.5 pulgadas al ver un fotografía con el formato alargado para la misma diagonal de pantalla.
  • La perdida de superficie de pantalla (tamaño real) es un 6.4 % al pasar de 16:9 a 18:9.
  • Para la misma diagonal la pantalla del anterior formato 16:9 rinde mucho mejor y ademas ocupa mas superficie, es mayor.

 

Tablas:

18:9

Pulgadas Películas Fotografías Area Total cm² Equivalencia 16:9

5

4.561

4.031

64.516

4.837

5,5

5.017

4.434

78.064

5.321

6

5.473

4.837

92.903

5.805

6,5

5.929

5.240

109.032

6.289

7

6.385

5.643

126.451

6.773

16:9

Pulgadas Películas Fotografías Area Total cm² Equivalencia 18:9

5

5

4.419

68.919

5.167

5,5

5.5

4.861

83.392

5.685

6

6

5.303

99.243

6.201

6,5

6,5

5.745

116.473

6.718

7

7

6.187

135.081

7.235

Peliculas

Pelicula

16:9

18:9

5

5

5.481

5,5

5,5

6.029

6

6

6.577

6,5

6,5

7.125

7

7

7.673

Apendices.

Matemática para los cálculos del programa.

a² + b² = h² Teorema de Pitágoras

16/9 = a/b => a = 16/9 b Proporción para pantallas 16:9

18/9 = a/b => a =18/9 b Proporción para pantallas 18:9

A = a * b Área del rectángulo en ambos casos.

  • A = 16/9 b² = 1.7777778 b²
  • A = 18/9 b² = 2 b²

(16/9)²b² + b² = h² => (256+81)/81 b² = h² => 4,1605 * b² = h² => b² = h² / 4.1605

(18/9)²b² + b² = h² => (4+1) * b² = h² => 5 * b² = h² => b² = h² / 5

Área en función de la diagonal

  • A = 16/9 * ( h² / 4.1605) = 0,427299703 h²
  • A = 18/9 * ( h² / 5 ) = 0.4 h²

En los cálculos de equivalencia se toma el lado menor de cada formato y se calcula la equivalencia usando la proporción 16:9 para películas y l proporción 3:2 para fotos

 

Programa para el calculo introduciendo la diagonal de tu teléfono.

El programa esta escrito en haskell, para ejecutarlo debes copiarlo en un archivo con extensión .hs y escribir en la terminal.

runhaskell NombrePrograma.hs

Para instalar haskell visita www.haskell.org o mira mi anterior entrada Haskell, instalación en Arch Linux

— Progrmama que compara las pantallas de movil de 16:9 y 18:9
— Calcula todos los datos a partir de la diagonal de la pantalla en pulgadas
— La entrada de este dato sera desde la terminal (numpulgadas)
main :: IO ()
— Funciones para el calculo de la longitud de los lados 16:9
— Lado mayor
dieciseisP :: Float -> Float
dieciseisP x = sqrt ((x ^ 2)/ 4.160493827)
— lado mayor
dieciseisG :: Float -> Float
dieciseisG x = 16.0 / 9.0 * dieciseisP x

— Funciones calculo de los lados para 18:9
— Lado menor

dieciochoP :: Float -> Float
dieciochoP x = sqrt ((x ^2) / 5)
— lado mayor
dieciochoG :: Float -> Float
dieciochoG x = 18.0 / 9.0 * dieciochoP x
— Areas 16:9 y 18:9
areadieciseis :: Float -> Float
areadieciseis x = 0.427299703 * x^2
areadieciocho :: Float -> Float
areadieciocho x = 0.4 * x^2
— Porcentaje de pantalla
porciento :: Float -> Float
porciento x = (1 – (areadieciocho x / areadieciseis x)) * 100.0
— El mismo area para los dos formatos
equivalencia :: Float -> Float
equivalencia x = sqrt(0.4) / sqrt(0.427299703) * x
— Como se ve una pelicula 16:9 en un telefono 18:9
movie :: Float -> Float
movie x = dieciochoP x * 2.039728861
— Como se ven fotografias 3:2 en ambos formatos
foto16 :: Float -> Float
foto16 x = dieciseisP x * 1.802775638
foto18 :: Float -> Float
foto18 x = dieciochoP x * 1.802775638
main = do
— Entrada de datos en terminal numpulgadas
putStrLn “Diagonal”
n <- getLine
let numpulgadas = read(n)
— pulgadas a centimetros
let num1 = 2.54 * numpulgadas

— salida de datos en terminal

— Lados y area en ambos formatos
putStrLn ” Movil 16:9″
putStrLn (“Lado Menor ” ++ ( show ( dieciseisP num1 )) ++ ” cm” )
putStrLn (“Lado Mayor ” ++ ( show ( dieciseisG num1 )) ++ ” cm” )
putStrLn ( “Area 16:9 ” ++ ( show (areadieciseis num1 )) ++ ” cm²”)
putStrLn ” Movil 18:9″
putStrLn (“Lado Menor “++ ( show (dieciochoP num1 )) ++ ” cm” )
putStrLn (“Lado Mayor ” ++ ( show (dieciochoG num1)) ++ ” cm”)
putStrLn ( “Area 18:9 ” ++ ( show (areadieciocho num1 )) ++ ” cm²”)
— Equivalencias entre formatos para el mismo area
putStrLn ( “Porcentaje de area que es ” ++ (show (porciento num1)) ++ ” % mayor”)
putStrLn ( ( show (numpulgadas)) ++ ” pulgadas en 16:9 ” ++ ” equivalen a ” ++ (show (equivalencia numpulgadas) ) ++ ” pulgadas en 18:9″ )
— Perdida en pantalla debido a los diferentes formatos de video y foto
putStrLn ( “La diagonal equivalente para peliculas en 18:9 es ” ++ (show (movie numpulgadas)) ++ ” pulgadas”)
putStrLn (“La diagonal equivalente para foto 3:2 en 16:9 es ” ++ (show (foto16 numpulgadas ) ) ++ ” pulgadas”)
putStrLn (“La diagonal equivalente para foto 3:2 en 18:9 es ” ++ (show (foto18 numpulgadas ) ) ++ ” pulgadas”)

 

Haskell, instalación en Arch Linux

Acabo de comenzar mis primeros pasos con este lenguaje de programación, funcional y distinto a otros en sintaxis y conceptos.

Os dejare referencias bibliográficas para los que empezáis como yo, también un video de como descargar e instalar el compilador y el entorno de desarrollo.

En las siguientes entradas y con el fin de practicar Haskel, los script o pequeños programas ya no serán escritos en C++, se escribirán en Haskell.

Instalación.

En mi caso soy usuario de Antergos una distribución basada en Arch Linux y mostrare como podéis instalarlo. Dejare referencias de como instalarlo en otras distribuciones. Así como donde descargarlo para Windows y MacOS.

Es importante para los que empezamos instalar lo mas básico y necesario el compilador ghci y cabal. Posteriormente instalaremos stack que es su entorno de desarrollo y ademas os añadirá muchas librerías.

sudo pacman -S ghc cabal-install happy alex haddock

sudo pacman -S stack

 

Bibliografía.

Primeramente la principal fuente, su propia pagina: https://www.haskell.org/

En la wiki nos explica de donde surgió el lenguaje y una breve descripción sobre él. https://es.wikipedia.org/wiki/Haskell

En mi caso, los primeros pasos los he dado siguiendo esta web y con estos libros.