Capturar webcam con VB.NET

¿Que haremos? Crearemos una aplicación en Visual Studio, la cual hará uso de una webcam para capturar el video en frames independientes y depositarlos en memoria para despues mostralos al usuario a través de un picturebox y un Timer para crear la ilusión de movimiento. ¿Porque lo haremos? Porque es justo y necesario ¿Que necesitamos? [...]

Envío de correo con JavaMail/Netbeans

JavaMail es una expansión de Java que facilita el envío y recepción de e-mail desde código java. JavaMail implementa el protocolo SMTP (Simple Mail Transfer Protocol) así como los distintos tipos de conexión con servidores de correo -TLS, SSL, autentificación con usuario y password, etc [Según SantaWikipedia] ¿Qué necesitamos? JavaMail 1.4.5 Java y Netbeans 6.9 [...]

Proyecto de base de datos Firebird VB

En este proyecto realizaremos una aplicación de base de datos Firebird con el lenguaje de programación de Visual Basic de Microsoft, este proyecto tendrá las funciones básicas de gestión INSERT, DELETE, UPDATE y una interfaz de usuario para utilizarlas. ¿Que necesitamos? Visual Studio 2008 o superior Firebird última versión Firebird ADO.NET Data Provider. Conocimientos básicos [...]

Imprimir imagen con Print

La siguiente clase hace uso de PRINT para imprimir una imagen que se encuentra en un variable de tipo FileInputStream, esta clase a su vez es implementada desde una interfaz que hace fácil su uso, la clase así como todo el proyecto esta comentado. import java.io.File; import javax.print.Doc; import java.io.IOException; import javax.print.DocFlavor; import javax.print.SimpleDoc; import java.io.FileInputStream; [...]

25/9/10

Cifrado de Vernam en java

JAN29

El cifrado de Vernam permite esconder mensajes secretos donde el texto se combina con una clave mediante operaciones matemáticas, mas info en Santa Wikipedia o el Santo patrono de los tecno-jovenes San Google.

Mejor un ejemplo, la teoria aburre:

1. Si queremos esconder el mensaje HOLA MUNDO, utilizando como plabra clave MOUSE, haremos lo siguiente, tomaremos como patron un "abcedario" en mayuscula donde cada caracter representa un digito, esto no siempre es asi, hay muchas variantes, podemos tomar tambien la tabla ascii como referencia o los bytes, etc.

A=0
B=1
C=2
D=3
E=5
F=5
G=6
H=7
I=8
J=9
K=10
L=12
M=12
N=13
O=14
P=15
Q=16
R=17
S=18
T=19
U=20
V=21
W=22
X=23
Y=24
Z=25
_= 26 //espacio en blanco

En total 27 caracteres

2. ahora intercambiamos cada caracter por su digito correspondiente en nuestro abcedario tanto en el texto del mensaje como en la palabra clave, sumamos ambas y realizamos la operacion MOD 27 (numero de caracteres de nuestro abcedario, 27 en nuestro ejemplo), el resultado que obtenemos lo reemplazamos por el caracter correspondiente en nuestro abecedario y ya tenemos el mensaje encriptado

H[7] + M[12] MOD 27 = T[19]
O[14] + O[14] MOD 27 = B[1]
L[11] + U[20] MOD 27 = E[4]
A[0] + S[18] MOD 27 = S[18]
_[26] + E[4] MOD 27 = D[3]
M[12] + M[12] MOD 27 = Y[24]
U[20] + O[14] MOD 27 = H[7]
N[13] + U[20] MOD 27 = G[6]
D[3] + S[18] MOD 27 = V[21]
O[14] + E[4] MOD 27 = S[18]

mensaje encriptado: TBESDYHGVS

Para desencriptar el mensaje, realizamos la operacion inversa, es decir:

27 + T[19] - M[12] MOD 27 = H[7]
.
.
.
y asi XD

AHORA EN JAVA:

La siguiente clase vernam.java, hace lo que hicimos mas arriba, pero utilizamos un abcdario mas completo, con mayusculas, minusculas, numeros y algunos caracteres especiales. Se hace uso de vectores para manipular los datos, si bien no es necesario, pero en fin...

import java.util.Enumeration;
import java.util.Vector;
/**
 * @web http://jc-mouse.blogspot.com/
 * @author Mouse
 */
public class vernam {
    //nuestro ABCDARIO 
    private String abcdario = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzáéíóú 1234567890@.,;:-+*/$#¿?!¡=()[]{}";    
       
    public vernam(){
        System.out.println("Cifrado de Vernam by jc Mouse");
        System.out.println();
    }
    
    public String encriptar(String texto, String clave){        
        String t="";
        int a,b;
        char c;
        int i = 0;
        /* Se transforma las cadenas de texto en vectores */
        Vector vtexto = to_vector(texto);
        Vector vclave = to_vector(clave);
        //se recorre uno a uno los elementos del vecto "texto", y junto al vector "clave" se realizan las 
        //operaciones para encriptar/desencritar el mensaje
        Enumeration e = vtexto.elements();        
        while (e.hasMoreElements()) {
            //se obtiene la posicion de cada caracter del mensaje respecto a nuestro abcdario
            char caracter = e.nextElement().toString().charAt(0);
            a = abcdario.indexOf(caracter);
            //se hace lo mismo para la "clave"
            b = abcdario.indexOf(vclave.get(i).toString().charAt(0));               
            //esto encripta el caracter de acuerdo al cifrado de vernam
            c = abcdario.charAt((a+b)%abcdario.length());            
            // muestra con detalle el proceso de encriptado
            //System.out.println(caracter+"[" + a + "] + " + vclave.get(i) + "[" + b + "] MOD " + abcdario.length() + " = " + c + "[" + ((a+b)%abcdario.length())+"]");
            //se concatena el resultado
            t = t + c;
            i++;               
            if(i==vclave.size()){i=0;}
         }         
         return t;
    }
    
     public String desencriptar(String texto, String clave){         
        String t="";
        int a,b;
        char c;
        int i =0;        
        Vector vtexto = to_vector(texto);
        Vector vclave = to_vector(clave);        
        Enumeration e = vtexto.elements();        
        while (e.hasMoreElements()) {
           a = abcdario.indexOf(e.nextElement().toString().charAt(0));
           b = abcdario.indexOf(vclave.get(i).toString().charAt(0));                
           c = abcdario.charAt((abcdario.length()+ a - b)%abcdario.length());               
           t = t + c;           
           i++;               
           if(i==vclave.size()){i=0;}
         }         
         return t;
     }
    
    /* metodo que transforma una cadena de texto a un vector*/
    private Vector to_vector(String texto){
        Vector v = new Vector(10,2);    
        //convertimos el texto en un array
        char[] array = texto.toCharArray();                
        //pasamos del array al vector
        for(int j=0;j<array.length;j++){
            v.addElement(array[j]);
        }
        return v;
    }     
}

La implementacion de esta clase para su ejecucion desde consola, es :


public class Main {
    public static void main(String[] args) {
        vernam cripto = new vernam();
        String clave = "mouse";
        String texto = "HOLA MUNDO mensaje encriptado utilizando el Cifrado de Vernam";
        
        System.out.println( "Texto original: "  + texto);
        System.out.println();
        System.out.println( "------------------------------------------------------------");
        System.out.println( "Mensaje encriptado: " );
        String t = cripto.encriptar(texto, clave);
        System.out.println(t);                
        System.out.println( "------------------------------------------------------------");
        System.out.println();
        System.out.println( "Mensaje desencriptado: " );
        System.out.println( cripto.desencriptar(t, clave) );
        System.out.println( "------------------------------------------------------------");
    }
}
el resultado:


Texto original: HOLA MUNDO mensaje encriptado utilizando el Cifrado de Vernam

------------------------------------------------------------
Mensaje encriptado: 
H[7] + m[38] MOD 90 = t[45]
O[14] + o[40] MOD 90 = í[54]
L[11] + u[46] MOD 90 =  [57]
A[0] + s[44] MOD 90 = s[44]
 [57] + e[30] MOD 90 = ][87]
M[12] + m[38] MOD 90 = y[50]
U[20] + o[40] MOD 90 = 3[60]
N[13] + u[46] MOD 90 = 2[59]
D[3] + s[44] MOD 90 = v[47]
O[14] + e[30] MOD 90 = s[44]
 [57] + m[38] MOD 90 = F[5]
m[38] + o[40] MOD 90 = #[78]
e[30] + u[46] MOD 90 = /[76]
n[39] + s[44] MOD 90 = =[83]
s[44] + e[30] MOD 90 = +[74]
a[26] + m[38] MOD 90 = 7[64]
j[35] + o[40] MOD 90 = *[75]
e[30] + u[46] MOD 90 = /[76]
 [57] + s[44] MOD 90 = L[11]
e[30] + e[30] MOD 90 = 3[60]
n[39] + m[38] MOD 90 = $[77]
c[28] + o[40] MOD 90 = @[68]
r[43] + u[46] MOD 90 = }[89]
i[34] + s[44] MOD 90 = #[78]
p[41] + e[30] MOD 90 = ;[71]
t[45] + m[38] MOD 90 = =[83]
a[26] + o[40] MOD 90 = 9[66]
d[29] + u[46] MOD 90 = *[75]
o[40] + s[44] MOD 90 = ([84]
 [57] + e[30] MOD 90 = ][87]
u[46] + m[38] MOD 90 = ([84]
t[45] + o[40] MOD 90 = )[85]
i[34] + u[46] MOD 90 = ?[80]
l[37] + s[44] MOD 90 = ![81]
i[34] + e[30] MOD 90 = 7[64]
z[51] + m[38] MOD 90 = }[89]
a[26] + o[40] MOD 90 = 9[66]
n[39] + u[46] MOD 90 = )[85]
d[29] + s[44] MOD 90 = -[73]
o[40] + e[30] MOD 90 = ,[70]
 [57] + m[38] MOD 90 = F[5]
e[30] + o[40] MOD 90 = ,[70]
l[37] + u[46] MOD 90 = =[83]
 [57] + s[44] MOD 90 = L[11]
C[2] + e[30] MOD 90 = g[32]
i[34] + m[38] MOD 90 = :[72]
f[31] + o[40] MOD 90 = ;[71]
r[43] + u[46] MOD 90 = }[89]
a[26] + s[44] MOD 90 = ,[70]
d[29] + e[30] MOD 90 = 2[59]
o[40] + m[38] MOD 90 = #[78]
 [57] + o[40] MOD 90 = H[7]
d[29] + u[46] MOD 90 = *[75]
e[30] + s[44] MOD 90 = +[74]
 [57] + e[30] MOD 90 = ][87]
V[21] + m[38] MOD 90 = 2[59]
e[30] + o[40] MOD 90 = ,[70]
r[43] + u[46] MOD 90 = }[89]
n[39] + s[44] MOD 90 = =[83]
a[26] + e[30] MOD 90 = ú[56]
m[38] + m[38] MOD 90 = /[76]
tí s]y32vsF#/=+7*/L3$@}#;=9*(]()?!7}9)-,F,=Lg:;},2#H*+]2,}=ú/
------------------------------------------------------------

Mensaje desencriptado: 
HOLA MUNDO mensaje encriptado utilizando el Cifrado de Vernam
------------------------------------------------------------
BUILD SUCCESSFUL (total time: 3 seconds)


FIN

Post recomendado