introducción a la seguridad

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
aes128-cbc
aes192-cbc
aes256-cbc
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.
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
arcfour
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
Protocolos de uso general y
particulares
PROTOCOLO
CyberCash
PROPÓSITO
Transacciones
electrónica de Fondos
DNSSEC
Sistemas de Dominio de
Nombres
IPSec
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
llamado Autenticación
( autentificación ).
es
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.2.3.4.-
Plaintext ( texto en claro)
Texto cifrado
Algoritmo de encripción
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);
}
}
}
#!/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 = 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 ();
}
}
}
}