INTRODUCCIÓN A LA SEGURIDAD

Transcripción

1 INTRODUCCIÓN A LA SEGURIDAD

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

3 Algoritmos de Cifrado Algoritmos de cifrado aes128-cbc aes192-cbc aes256-cbc 3des-cbc blowfish-cbc cast128-cbc arcfour Descripción 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. 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 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 CAST-128 es un algoritmo parecido a DES que tiene buena resistencia al análisis criptográfico. Arcfour es un algoritmo basado en RC4 y SHA-1, simétrico y de stream. Tiene un nivel bajo en seguridad

4 Protocolos de uso general y particulares PROTOCOLO CyberCash PROPÓSITO Transacciones electrónica de Fondos DNSSEC IPSec Sistemas de Dominio de Nombres Encripción a nivel de paquete

5 Algoritmos RSA ( Rivest, Shamir, Adelman) ElGamal( Taher ElGamal)

6 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

7 Seguridad Proveer identificación es llamado Autenticación ( autentificación ).

8 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.

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

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

11 Criptografía Todos los sistemas criptográficos, sin importar su complejidad tienen las siguientes cuatro partes básicas:....

12 Criptografía 1.- Plaintext ( texto en claro) 2.- Texto cifrado 3.- Algoritmo de encripción 4.- Llave

13 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.

14 Criptología Algoritmo de encripción Esta es la operación para convertir texto en claro en texto cifrado y viceversa.

15 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.

16 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.

17 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.

18 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.

19 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.

20 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.

21 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.

22 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.

23 Criptografía Simétrica Significa que la misma llave secreta es usada para encriptar y desencriptar el mensaje. Fueron los primeros algoritmos.

24 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.

25 Criptografía Algunos algoritmos simétricos: DES (Data Encryption Standard) Triple DES RC2, RC4, RC5 IDEA Blowfish

26 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.

27 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.

28 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).

29 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

30 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.

31 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.

32 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

33 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

34 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

35 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

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

37 Código en lenguaje Java /*Ejemplo de uso de JCE Java Cryptography Extension 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);

38 /* 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);

39 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);

40 #!/usr/local/bin/perl -w Lenguaje Perl # # 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 = $key = $arch_entrada = $arch_salida = 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;

41 /*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); Lenguaje #C 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, ;

42 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;

43 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 ();