¿Cómo utilizar JAVA para implementar cifrado y descifrado de cadenas simples?

// Parámetros: (ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE, UNWRAP_MODE)

c1.init(Cipher.ENCRYPT_MODE, key, sr );

// Codifica el contenido a cifrar,

cipherByte = c1.doFinal(info.getBytes()

} catch (Exception e); ) {

e.printStackTrace();

}

// Devuelve la forma hexadecimal del texto cifrado

return byte2hex(cipherByte ) ;

}

/**

* Descifrado DES basado en clave

*

* @ param key

* Clave

* @param sInfo

* El texto cifrado a descifrar

* @return Cadena después del descifrado Información

*/

public String decryptByDES(SecretKey key, String sInfo) {

// Definir algoritmo de cifrado,

String Algorithm = " DES";

// Generador de números aleatorios cifrados (RNG)

SecureRandom sr = new SecureRandom();

byte[] cipherByte = null ;

try {

// Obtener el cifrado/descifrador

Cipher c1 = Cipher.getInstance(Algorithm);

// Inicializar el cifrado objeto con la clave y el modo especificados

c1.init(Cipher.DECRYPT_MODE, key, sr);

// Codifica el contenido a descifrar

cipherByte = c1.doFinal(hex2byte(sInfo));

} catch (Excepción e) {

e.printStackTrace();

}

// return byte2hex(cipherByte);

return new String(cipherByte);

}

// /// ///// ////////////////////

/////////////////////////////////////////////////// //// //

/**

* Crea un grupo de claves y coloca la clave pública y la clave privada en el archivo especificado

*

* De forma predeterminada, se coloca en el archivo mykeys.bat

*/

public void createPairKey() {

try {

// Un generador de pares de claves basado en un algoritmo específico

KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");

// Generador de números aleatorios cifrados ( RNG)

SecureRandom random = new SecureRandom();

// Restablecer la semilla de este objeto aleatorio

random.setSeed(1000);

// Inicializa un generador de pares de claves del tamaño de una clave utilizando la fuente aleatoria dada (y el conjunto de parámetros predeterminado)

keygen.initialize(512, random); // keygen.initialize(512);

// Generar grupo de claves

KeyPair llaves = keygen.generateKeyPair();

// Obtener la clave pública

PublicKey pubkey = llaves.getPublic();

// Obtener la clave privada

PrivateKey prikey = llaves.getPrivate();

// Obtener la clave pública para la clave privada Escribe en el archivo

doObjToFile("mykeys.bat", new Object[] { prikey, pubkey }

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

}

/**

* Utilice la clave privada para firmar la información Coloque la información firmada en el archivo especificado

*

* @param info

* Información a firmar

*. @param signfile

* Archivo almacenado

*/

public void signToInfo(String info, String signfile) {

// Leer la clave privada del archivo

PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);

// Lee la clave pública del archivo

PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);

try {

// El objeto de firma se puede utilizar para generar y verificar datos digitales firmas< /

p>

Firma signet = Signature.getInstance("DSA");

// Inicializa la clave privada para firmar la firma

signet.initSign(myprikey);

// Actualiza los datos a firmar o verificar por bytes

signet.update(info.getBytes());

// Firma o verifica todos los bytes actualizados Firmar , devolver firma

byte[] firmado = signet.sign();

// Coloca la firma digital, la clave pública y la información en el archivo

doObjToFile(signfile, new Object[] { firmado, mypubkey, info });

} catch (Excepción e) {

e.printStackTrace(); > }

}

/**

* Leer el archivo de firma digital para verificar la legalidad de la información en base a la clave pública, firma e información

*

* @return true si la verificación es exitosa false si la verificación falla

*/

public boolean validarSign(String signfile) {

// Leer la clave pública

PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);

// Leer la firma

byte[] firmado = (byte[]) getObjFromFile(signfile, 1);

// Leer información

String info = (String) getObjFromFile(signfile, 3);

try {

//Inicializar un objeto Firma y verificarlo con la clave pública y la firma

Signature signetcheck = Signature.getInstance("DSA ");

// Inicializa la clave pública para la verificación de firma

signetcheck.initVerify(mypubkey);

// Usa la matriz de bytes especificada para actualizar la datos a firmar o verificar

signetcheck.update(info.getBytes());

System.out.println(info);

// Verificar la firma entrante

return signetcheck .verify(signed);

} catch (Exception e) {

e.printStackTrace(); p> devuelve falso;

}

}

/**

* Convertir cadena binaria a hexadecimal

*

* @param b

* Matriz de bytes binarios

p>

* @return String

*/

public String byte2hex(byte[] b) {

String hs = "" p>

String stmp = "";

for (int n = 0; n lt; b.length; n ) {

stmp = (java.lang) .Integer .toHexString(b[n] amp; 0XFF));

if (stmp.length() == 1) {

hs = hs "0" stmp;

} else {

hs = hs stmp;

}

}

return hs.toUpperCase() ;

}

/**

* Convertir cadena hexadecimal a binaria

*

* @param hexadecimal

* @return

*/

byte público[] hex2byte(String hexadecimal) {

byte[ ] ret = nuevo byte[8];

byte[] tmp = hex.getBytes();

for (int i = 0; i lt; 8; i) {

ret[i] = unitBytes(tmp[i * 2], tmp[i * 2 1]);

}

return ret; }

/**

* Combina dos caracteres ASCII en un byte, como por ejemplo: "EF"--gt;

* @param src0

* byte

* @param src1

* byte

* @ retorno byte

*/

byte estático público uniteBytes(byte src0, byte src1) {

byte _b0 = Byte.decode("0x" nueva cadena( nuevo byte[] { src0 }))

.byteValue();

_b0 = (byte) (_b0 lt; lt; 4);

byte _b1 = Byte.decode; ("0x" nueva cadena (nuevo byte[] { src1 }))

.byteValue();

byte ret = (byte) (_b0 ^ _b1

return ret;

}

/**

* Escribe el objeto especificado en el archivo especificado

*

* @param file

* Especifica el archivo a escribir

*

@param objs

* El objeto a escribir

*/

public void doObjToFile(String file, Object[] objs) {

ObjectOutputStream oos = null

prueba {

FileOutputStream fos = new FileOutputStream(file);

oos = new ObjectOutputStream(fos); >

for (int i = 0; i lt; objs.length; i ) {

oos.writeObject(objs[i]);

}

} catch (Excepción e) {

e.printStackTrace();

} finalmente {

prueba {

oos .close();

} captura (IOException e) {

e.printStackTrace()

}

} p>

}

/**

* Devuelve el objeto en la posición especificada en el archivo

*

* @param file

* El archivo especificado

* @param i

* A partir de 1

* @return

*/

objeto público getObjFromFile(archivo de cadena, int i) {

ObjectInputStream ois = null

objeto obj = null; /p>

intente {

FileInputStream fis = new FileInputStream(file);

ois = new ObjectInputStream(fis

for (int j); = 0; j lt; i; j) {

obj = ois.readObject();

}

} captura (Excepción e) {

e.printStackTrace();

} finalmente {

prueba {

ois.close(); } catch (IOException e) {

e.printStackTrace();

}

}

return obj;

}

/**

* Prueba

*

* @param args

* /

público estático vacío principal(St

ring[] args) {

CryptTest jiami = new CryptTest();

// Realiza el cifrado MD5 "¡Hola mundo!"

System.out.println ("Hola a través de MD5:" jiami.encryptToMD5("Hola"));

// Genera una clave de algoritmo DES

Clave SecretKey = jiami.createSecretKey("DES" );

// Usa la clave para cifrar el mensaje "¡Hola mundo!"

String str1 = jiami.encryptToDES(key, "Hello");

System .out.println("Usa des para cifrar información Hola: " str1);

// Usa esta clave para descifrar

String str2 = jiami.decryptByDES(key, str1);

System.out.println("Después del descifrado: " str2);

// Crear claves públicas y privadas

jiami.createPairKey(); p>

// Usa la clave privada para firmar ¡Hola mundo!

jiami.signToInfo("Hello", "mysign.bat"); verifica la firma.

if (jiami.validateSign("mysign.bat")) {

System.out.println("¡Éxito!");

} else {

System.out.println("¡Fallo!"

}

}

}