INTRODUCCIÓN A LA

SEGURIDAD

Seguridad

• Cuando usas una computadora usualmente usa un nombre y un password (clave / contraseña ) para autenticarte.

“Algoritmos de Cifrado”

Algoritmos de cifrado Descripción

aes128-cbc

aes192-cbc

aes256-cbc

AES(Advanced Encryption Standerd) estándar adoptado por el gobierno de

U.S.A. que remplazó a DES/3DES. AES también es conocido como el

algoritmo de encrypcion Rijndael, el cual es mas rápido. El número después del nombre del algoritmo es el tamaño de cifrado que usa.

3des-cbc DES y 3DES son los primeros algoritmos de encriptamiento disponibles.

Desarrollados por la NSA (Nacional Security Agency de USA), a principios

de los 70. estos algoritmos han sido susceptibles a análisis criptográfico, por lo que no son muy recomendados si se tiene otros algoritmos

blowfish-cbc Blowfish es un algoritmo de cifrado en bloque con llave simétrica diseñado

por Schneier que usa una llave de tamaño variable y un bloque de 64 bits. La

llave puede ser de 32 a 448 bits. Los datos son filtrados por la función de encriptamiento 16 veces

cast128-cbc CAST-128 es un algoritmo parecido a DES que tiene buena resistencia al

análisis criptográfico. arcfour Arcfour es un algoritmo basado en RC4 y SHA-1, simétrico y de stream.

Tiene un nivel bajo en seguridad

Protocolos de uso general y particulares

PROTOCOLO

CyberCash

DNSSEC

IPSec

PROPÓSITO

Transacciones electrónica de Fondos

Sistemas de Dominio de Nombres

Encripción a nivel de paquete

Algoritmos

• RSA ( Rivest, Shamir, Adelman)

• ElGamal( Taher ElGamal)

Protocolos de uso general y particulares

PROTOCOLO

• PCT

• PGP

• S/MIME

• S-HTTP

PROPÓSITO

Encriptamiento a nivel de TCP/IP

• Correo electrónico

• Correo electrónico

• El desplegado en WEB

Seguridad

• Proveer identificación es llamado Autenticación

( autentificación ).

Definición de Criptografía

• Criptografía es la ciencia de la escritura secreta, es un brazo de las matemáticas, la criptología, tiene otro hijo, que es el criptoanálisis y esta es la ciencia que analiza la criptografía. Las acciones principales de seguridad en las aplicaciones están dirigidas por la criptografía. Principalmente, las aplicaciones necesitan asegurarse que los usuarios son quienes dicen ser.

Seguridad

• La criptología provee soluciones.

• La criptología provee métodos más seguros, llamados firmas y certificados.

Seguridad

• La seguridad en las aplicaciones están dirigidas por la criptografía.

Criptografía

Todos los sistemas criptográficos,

sin importar su complejidad tienen

las siguientes cuatro partes

básicas: .

.

.

.

Criptografía

1.- Plaintext ( texto en claro)

2.- Texto cifrado

3.- Algoritmo de encripción

4.- Llave

Criptografía

• Texto cifrado

Este es el mensaje en texto en claro

que ha sido modificado para hacerlo

ilegible. El proceso de convertir texto

en claro a texto cifrado se dice

encriptar y la operación inversa es

desencriptar.

Criptología

• Algoritmo de encripción

Esta es la operación para

convertir texto en claro en texto

cifrado y viceversa.

• Aun datos en el disco duro de una computadora están disponibles para los compañeros de trabajo, ó cualquiera otra persona que tenga acceso físico a la computadora. Para proteger los datos del disco duro, es posible encriptarlos antes de escribirlos en el disco. Y desencriptar el texto cifrado cuando se quiera ver la información (ó cuando requieras imprimirlos el archivo). Como ejemplo de un cifrador podemos hablar del ROT13. El ROT13.es un cifrador muy simple.

• El algoritmo del ROT13 simplemente rota cada carácter de un mensaje 13 posiciones. ROT13 originalmente se desarrollo para ocultar posibles bromas (chistes) ofensivos en los news grups en internet.

• Si la información era vista por otra persona no lo entendería. Para revisar la información es necesario desencriptarla. El ROT13 no es seguro.

• Los cifradores útiles usan llaves para encriptar y desencriptar datos.

Criptología

• Llave Este es una llave secreta usada para encriptar

ó desencriptar el mensaje. Cada llave

transforma el mismo texto en claro en un

diferente texto cifrado. Si el sistema funciona

bien, solamente las personas que conocen la

llave correcta pueden descifrar el texto

cifrado.

Criptología La criptología nos permite que el texto

cifrado pueda ser transmitido a través de canales públicos de comunicación inseguros aun si el texto cifrado es interceptado no tiene ninguna utilidad si no se tiene la llave de desencriptamiento.

Criptología • Antes de la llegada de las computadoras

digitales el texto en claro, el texto cifrado y la llave estaban en forma de texto leído por humanos.

• Ahora son cadenas arbitrarias de información binaria.

• Vídeo, sonido y software pueden ser encriptadas tan fácil como el texto en claro.

Criptología

Una importante característica de un buen sistema es que la seguridad del sistema depende completamente en la secrecía de la llave de desencriptamiento.

Criptografía

• No es necesario guardar en secreto el algoritmo de encriptamiento.

• Permite al algoritmo a ser rehusado por muchas personas y evita la necesidad de proteger el software de encriptamiento.

Criptografía

El texto cifrado puede ser “craked” (roto) y leído por usuarios no autorizados en varias formas.

Una forma es a través del criptoanálisis

Criptografos entrenados analizan el texto cifrado en busca de patrones residuales dejados desde el texto en claro.

Criptografía

Cualquiera de estos patrones pueden ser usadas para reconstruir el mensaje original ó la llave usada para encriptar.

Un buen algoritmo de encriptamiento es uno que no genera estos patrones.

Criptografía Simétrica

• Significa que la misma llave secreta es usada para encriptar y desencriptar el mensaje.

• Fueron los primeros algoritmos.

Criptografía Asimétrica • Los cifradores asimétricos (también llamados

cifradores de llaves públicas) involucran una llave pública, que puede ser libremente distribuida, y una llave privada, que puede ser secreta. Estas llaves siempre son generadas en parejas. Llaves públicas realmente son públicas, se puede publicarlas en un periódico, pero nadie puede violar tú privacidad sin la llave privada. El mecanismo de distribuir las llaves públicas, sin embargo, es un gran reto.

Criptografía

Algunos algoritmos simétricos: • DES (Data Encryption Standard)

• Triple DES

• RC2, RC4, RC5

• IDEA

• Blowfish

Una de las llaves se llama la llave pública y se distribuye ampliamente.

La otra llave llamada privada y es guardada en secreto.

Para enviar un mensaje se encripta con la llave pública de la persona de la que le quieres enviar, esta persona usa su llave privada para desencriptar el mensaje.

• La principal limitación de la criptografía de la llave pública es velocidad.

• La implementación más rápida de RSA es miles de veces más lenta que los algoritmos simétricos.

• Esto los hace imprácticos para encriptar mensajes largos.

• Generalmente los sistemas mezclan a los algoritmos de llave pública y simétrica.

Firmas Digitales:

Los algoritmos de llave pública permite también crear firmas digitales.

Mensajes encriptados usando la llave privada solo pueden ser desencriptados usando la llave pública.

Esto crea declaraciones de identidad(firmas digitales).

Integridad de Mensajes

• El encriptamiento no asegura la integridad de los mensajes

• MD4 y MD5 son funciones de hash(dispersión) en un solo sentido que generan cadenas de 128 bits

• MD5 es un reemplazo de MD4 después de haber detectado ciertas debilidades

Estas funciones actúan como huellas digitales de los mensajes originales.

Si se integran a los mensajes encripados nos aseguran que nadien modificó el mensaje y que además el mensaje esta integro.

Sobres digitales

• Aunque los sistemas de encripción pública son ideales para Internet tiene un problema muy grave, son de ordenes de magnitud más lento que los sistemas simétricos.

• Los sistemas simétricos tiene el problema de distribución de la llave.

La solución es mezclar los dos.

1.- Genera una llave secreta random para un algoritmo simétrico

2.- Encrpita la llave secreta con la llave pública y enviala

3.- El receptor desencripta el mensaje con su llave privada y obtiene la llave secreta

4.- Las dos partes tiene una llave para un algoritmo simétrico

Certifying authorities (autoridades certicadoras o Cas)

• Dos problemas prácticos de los algoritmos de llave pública son:

– El estar seguro que la llave pública es de quien dice ser su dueño

– El número de llaves públicas que se tienen que guardar

• Una solución a esto son los CAs para la validación de las llaves públicas

• los CAs son compañías que dan fe de la identidad de individuos y organizaciones

• En lugar de tener la llave pública de todo mundo en tu disco duro solo guardas las llaves públicas de unos cuantos Cas conocidos

• Los certificados no son más que mensajes encriptados con la llave privada de un CA que contiene la llave pública del individuo así como sus datos

DES Y 3DES DESARROLLADAS EN LOS LENGUAJES JAVA, PERL Y #C

Código en lenguaje Java /*Ejemplo de uso de JCE 1.2.1 Java Cryptography Extension 1.2.1 Este programa encrypta/desencrypta con DES y 3DES

( TRIPLEDES ) Se puedesn usar llaves de 8 o 24 bytes ( para DES o

3DES )*/ import java.io.*; import java.security.*; import java.security.spec.*; import javax.crypto.*; import javax.crypto.spec.*; import javax.crypto.SecretKeyFactory.*; public class td { public static void main(String[] args) { int i,largo; String NombreAlgo; /* esta es la base para la llave */ byte [] a = { (byte) 1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7, (byte)8, (byte) 1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7, (byte)8, (byte) 1, (byte)2, (byte)3, (byte)4, (byte)5, (byte)6, (byte)7, (byte)8,};

SecretKey key = null; boolean dir; /* si encripta o desencripta */ boolean algo; /* si des o 3des */ if( args.length != 4 ){ System.out.println( "Uso: encripta {e|d|E|D} llave archivo1 archivo2"); /* e : encripta con DES d : desencripta con DES E : encripta con 3DES D : desencripta con 3DES */ System.exit(1); } if( args[0].equals("e") && args[0].equals("d") && args[0].equals("E") && args[0].equals("D")){ System.out.println( "Uso: encripta {e|d|E|D} llave archivo1 archivo2"); System.exit(1); }

/* dinamicamente configuramos a SunJCE */ Security.addProvider( new com.sun.crypto.provider.SunJCE() ); /* dir es true si encripta */ dir = args[0].equals("e") || args[0].equals("E") ; /* algo es el algoritmo, si es true = DES es flase = 3DES */ algo = args[0].equals("e") || args[0].equals("d") ; if( algo ) NombreAlgo = "DES"; else NombreAlgo = "DESede"; if( algo ) largo = 8; else largo = 24; if( args[1].length() < largo ) largo = args[1].length(); for(i=0;i<largo;i++) a[i] = (byte) args[1].charAt(i); try { if( algo ){ // DES DESKeySpec dks = new DESKeySpec( a ); SecretKeyFactory kf = SecretKeyFactory.getInstance(NombreAlgo); key = kf.generateSecret(dks); } else { // DESede DESedeKeySpec dks = new DESedeKeySpec( a ); SecretKeyFactory kf = SecretKeyFactory.getInstance(NombreAlgo); key = kf.generateSecret(dks); } }

catch( InvalidKeyException ik ){ System.out.println("LLAVE INVALIDA, adios"); System.exit(1); } catch( NoSuchAlgorithmException ex ){ System.out.println(" No encontre a " + NombreAlgo); System.exit(1); } Cipher ci = null; try { if( algo ) // DES ci = Cipher.getInstance("DES/ECB/PKCS5Padding"); else // 3DES ci = Cipher.getInstance("DESede/ECB/PKCS5Padding"); if( dir ) ci.init(Cipher.ENCRYPT_MODE,key); else ci.init(Cipher.DECRYPT_MODE,key); } catch( InvalidKeyException ik ){ System.out.println("LLAVE INVALIDA, adios ups"); System.exit(1); }

catch( NoSuchAlgorithmException ex ){ System.out.println(" No encontre a " + NombreAlgo +

"/ECB/PKCS5Padding"); System.exit(1); } catch( NoSuchPaddingException ex ){ System.out.println(" No encontre a " + NombreAlgo +

"/ECB/PKCS5Padding"); System.exit(1); } if( dir ) encripta(ci,args[2],args[3]); else desencripta(ci,args[2],args[3]); } public static void encripta(Cipher ci, String entrada, String

salida){ try { BufferedInputStream l = new BufferedInputStream ( new FileInputStream(entrada)); CipherOutputStream esc = new CipherOutputStream( new BufferedOutputStream ( new FileOutputStream(salida)), ci); int c; while( ( c = l.read() ) != -1 ) esc.write(c); l.close(); esc.close(); }

catch( IOException exiii){ System.out.println("Error de lectura o escritura"); System.exit(1); } } public static void desencripta(Cipher ci, String entrada, String

salida){ try { CipherInputStream le = new CipherInputStream( new BufferedInputStream ( new FileInputStream(entrada)),ci); BufferedOutputStream esc = new BufferedOutputStream ( new FileOutputStream(salida)); int c; while( ( c = le.read() ) != -1 ) esc.write(c); le.close(); esc.close(); } catch( IOException exiii){ System.out.println("Error de lectura o escritura"); System.exit(1); } } }

Lenguaje Perl #!/usr/local/bin/perl -w # # Encripta y desencripta con DES y 3DES (DES_EDE3) # en perl # use Crypt::CBC; use strict; my($cipher,$algo,$key,$arch_entrada,$arch_salida); my($uso,$dir,$nombrealgo,$buffer,$l); $uso = "Uso: encripta {e|d|E|D} llave archivo1

archivo2\n"; $algo = shift @ARGV; $key = shift @ARGV; $arch_entrada = shift @ARGV; $arch_salida = shift @ARGV; if( index("edED",$algo) == -1 || length($algo) != 1 ){ print $uso; exit 1; } # dir es true si encrypta $dir = ( $algo eq 'e' || $algo eq 'E' ); # algo es el algoritmo, true si es DES o false si es

3DES ( DES_EDE3) $algo = ( $algo eq 'e' || $algo eq 'd' );

# el nombre del algoritmo $nombrealgo = $algo ? "DES" : "DES_EDE3"; $cipher = new Crypt::CBC($key,$nombrealgo); open(ENTRADA,$arch_entrada) or die "Error al abrir

a $arch_entrada;$!"; open(SALIDA,">$arch_salida") or die "Error al abrir a

$arch_salida;$!"; print ( $dir ? 'encrypting' : 'decrypting' ); $cipher->start( $dir ? 'encrypting' : 'decrypting' ); while( sysread(ENTRADA,$buffer,1024) ){ $l = $cipher->crypt($buffer); syswrite(SALIDA,$l, length($l)); } $l = $cipher->finish(); syswrite(SALIDA,$l, length($l)); close ENTRADA; close SALIDA;

Lenguaje #C

/*Versión del algoritmo DES y 3DES(tripleDES) en lenguaje #C */

using System.Globalization; using System.Runtime.InteropServices; namespace System.Security.Cryptography { #if NET_2_0 [ComVisible (true)] #endif public abstract class DES : SymmetricAlgorithm { private const int keySizeByte = 8; #if NET_2_0 protected DES () #else public DES () #endif { KeySizeValue = 64; BlockSizeValue = 64; FeedbackSizeValue = 8; LegalKeySizesValue = new KeySizes[1]; LegalKeySizesValue[0] = new KeySizes(64, 64, 0); LegalBlockSizesValue = new KeySizes[1]; LegalBlockSizesValue[0] = new KeySizes(64, 64, 0); }

public static new DES Create () { return Create ("System.Security.Cryptography.DES"); } public static new DES Create (string algo) { return (DES) CryptoConfig.CreateFromName (algo); } internal static sololectura byte[,] weakKeys = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, { 0x1F, 0x1F, 0x1F, 0x1F, 0x0F, 0x0F, 0x0F, 0x0F }, { 0xE1, 0xE1, 0xE1, 0xE1, 0xF1, 0xF1, 0xF1, 0xF1 }, { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }, }; internal static sololectura byte[,] semiWeakKeys = { { 0x00, 0x1E, 0x00, 0x1E, 0x00, 0x0E, 0x00, 0x0E }, { 0x00, 0xE0, 0x00, 0xE0, 0x00, 0xF0, 0x00, 0xF0 }, { 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE }, { 0x1E, 0x00, 0x1E, 0x00, 0x0E, 0x00, 0x0E, 0x00 }, { 0x1E, 0xE0, 0x1E, 0xE0, 0x0E, 0xF0, 0x0E, 0xF0 }, { 0x1E, 0xFE, 0x1E, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE }, { 0xE0, 0x00, 0xE0, 0x00, 0xF0, 0x00, 0xF0, 0x00 }, { 0xE0, 0x1E, 0xE0, 0x1E, 0xF0, 0x0E, 0xF0, 0x0E }, { 0xE0, 0xFE, 0xE0, 0xFE, 0xF0, 0xFE, 0xF0, 0xFE }, { 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00 }, { 0xFE, 0x1E, 0xFE, 0x1E, 0xFE, 0x0E, 0xFE, 0x0E }, { 0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF0, 0xFE, 0xF0 }, };

public static bool IsWeakKey (byte[] rgbKey) { #if NET_2_0 if (rgbKey == null) throw new CryptographicException (Locale.GetText ("No hay

llave")); #endif if (rgbKey.Length != keySizeByte) throw new CryptographicException (Locale.GetText ("Longitud

de llave incorrecta")); for (int i=0; i < rgbKey.Length; i++) { switch (rgbKey [i] | 0x11) { case 0x11: case 0x1F: case 0xF1: case 0xFF: break; default: return false; } } for (int i=0; i < (weakKeys.Length >> 3); i++) { int j = 0; for (; j < rgbKey.Length; j++) { if ((rgbKey [j] ^ weakKeys [i,j]) > 1) break; } if (j==8) return true; } return false; }

} if (j==8) return true; } return false; } public static bool IsSemiWeakKey (byte[] rgbKey) { #if NET_2_0 if (rgbKey == null) throw new CryptographicException (Locale.GetText

("No hay llave")); #endif if (rgbKey.Length != keySizeByte) throw new CryptographicException (Locale.GetText

("Longitud de llave incorrecta")); for (int i=0; i < rgbKey.Length; i++) { switch (rgbKey [i] | 0x11) { case 0x11: case 0x1F: case 0xF1: case 0xFF: break; default: return false; } }

for (int i=0; i < (semiWeakKeys.Length >> 3); i++) {

int j = 0; for (; j < rgbKey.Length; j++) { if ((rgbKey [j] ^ semiWeakKeys [i,j]) > 1) break; } if (j==8) return true; } return false; } public override byte[] Key { get { if (KeyValue == null) { GenerateKey (); } return (byte[]) KeyValue.Clone (); }

set { if (value == null) throw new ArgumentNullException

("Llave"); if (value.Length != keySizeByte) throw new ArgumentException

(Locale.GetText ("Longitud de llave incorrecta"));

if (IsWeakKey (value)) throw new CryptographicException

(Locale.GetText ("Llave dévil")); if (IsSemiWeakKey (value)) throw new CryptographicException

(Locale.GetText ("Llave semi dévil")); KeyValue = (byte[]) value.Clone (); } } } }