1. Cifrado y descifrado DES
paquete com.itjh.javaUtil;importar java.io.UnsupportedEncodingException;importar java.security.InvalidKeyException;importar java.security.NoSuchAlgorithmException;importar java.security.SecureRandom;importar java.security.spec.InvalidKeySpecException;importar javax.crypto.BadPaddingException ;importar javax.crypto.Cipher;importar javax.crypto.IllegalBlockSizeException;importar javax.crypto.KeyGenerator;importar javax.crypto.NoSuchPaddingException;importar javax.crypto.SecretKey;importar javax.crypto.SecretKeyFactory;importar javax.crypto.spec.DESKeySpec;/** * cifrado DES y Descifrar. * * @author Song Lijun* @fecha 3 de julio de 2014*/public class DESUtil {/** Clave de seguridad*/private String keyData = "ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstwxyz0123456789-_.";/** * Función: Construcción* * @author Song Lijun * @fecha 3 de julio de 2014 */public DESUtil() {}/** * Función: Construcción* * @author Song Lijun* @fecha 3 de julio de 2014* @param keyData * key */public DESUtil(String key) { this.keyData = clave;}/** * Función: Cifrado (UTF-8) * * @autor Song Lijun* @fecha 3 de julio de 2014* @param source * Cadena de origen * @param charSet * Codificación * @return String * @throws UnsupportedEncodingException * Excepción de codificación */public String encrypt(String source) throws UnsupportedEncodingException {return encrypt(source, "UTF-8");}/ * * * * Función: Descifrado (UTF-8) * * @autor Song Lijun* @fecha 3 de julio de 2014* @param encryptedData * Cadena cifrada * @return String * @throws UnsupportedEncodingException * Excepción de codificación */public String decrypt(String encryptedData)throws UnsupportedEncodingException {return decrypt(encryptedData, "UTF-8");}/** * Función: Cifrado* * @autor Song Lijun* @fecha 3 de julio de 2014* @param fuente * Cadena de origen * @param charSet * Codificación * @return String * @throws UnsupportedEncodingException * Excepción de codificación */public String encrypt(String source, String charSet)throws UnsupportedEncodingException {String encrypt = null;byte[] ret = encrypt(source.getBytes ( charSet));encrypt = new String(Base64.encode(ret));return encrypt;}/** * * Función: Descifrado * * @author Song Lijun * @fecha 3 de julio de 2014 * @param encryptedData * Cadena cifrada * @param charSet * Codificación * @return String * @throws UnsupportedEncodingException * Excepción de codificación */public String decrypt(String encryptedData , String charSet) lanza UnsupportedEncodingException {String descryptedData = null;byte[] ret = descrypt(Base64.decode(encryptedData.toCharArray()));descryptedData = new String(ret, charSet);return descryptedData;}/** * Los datos cifrados utilizan la clave generada para cifrar los datos originales * * @param PrimaryData * Datos originales * @return byte[] * @autor Song Lijun* @fecha 3 de julio de 2014*/privado byte[] encrypt(byte[] PrimaryData) {/** Obtener la clave de seguridad*/byte rawKeyData[] = getKey();/** El algoritmo DES requiere una fuente de números aleatorios confiable*/SecureRandom sr = new SecureRandom () ;/** Cree un objeto DESKeySpec utilizando los datos clave originales*/DESKeySpec dks = null;try {dks = new DESKeySpec(keyData.getBytes());} catch (InvalidKeyException e) {e.printStackTrace();}/** Crear una fábrica de claves*/SecretKeyFactory keyFactory = null;try {keyFactory = SecretKeyFactory.getInstance("DES");} catch (NoSuchAlgorithmException e) {e.printStackTrace ( );}/** Utilice la fábrica de claves para convertir DESKeySpec en un objeto SecretKey*/SecretKey key = null;try {key = keyFactory.generateSecret(dks);} catch (InvalidKeySpecException e) {e.printStackTrace();}/** El objeto Cipher realmente completa la operación de cifrado*/Cipher cipher = null;try {cipher = Cipher .getInstance ("DES");} captura (NoSuchAlgorithmException e) {e.printStackTrace();} captura (NoSuchPaddingException e) {e.printStackTrace();}/** Inicializar objeto Cipher con clave*/try {cipher.init(Cipher.ENCRYPT_MODE, key, sr);} catch (InvalidKeyException e) {e.printStackTrace();}/* * Realizar formalmente la operación de cifrado*/byte encryptedData[] = null;try {encryptedData = cipher.doFinal(primaryData);} catch (IllegalStateException e) {e.printStackTrace();} catch (IllegalBlockSizeException e) {e.printStackTrace();} catch (BadPaddingException e) {e.printStackTrace();}/** Devolver datos cifrados*/return encryptedData;} /** * Descifrar datos con clave* * @param encryptedData * Datos cifrados * @return byte[] * @author Song Lijun* @fecha 3 de julio de 2014*/private byte[] descrypt(byte[] encryptedData) {/** El algoritmo DES requiere una fuente de números aleatorios confiable*/SecureRandom sr = new SecureRandom();/* * Obtenga el clave de seguridad */byte rawKeyData[] = getKey();/** Cree un objeto DESKeySpec utilizando los datos de clave sin procesar */DESKeySpec dks = null; {dks = new DESKeySpec(keyData.getBytes());} catch (InvalidKeyException e) {e.printStackTrace();}/** Crear una fábrica de claves*/SecretKeyFactory keyFactory = null;try {keyFactory = SecretKeyFactory.getInstance( " DES");} captura (NoSuchAlgorithmException e) {e.printStackTrace();}/** Utilice la fábrica de claves para convertir DESKeySpec en un objeto SecretKey */SecretKey key = null;try {key = keyFactory.generateSecret(dks);} catch (InvalidKeySpecException e) {e.printStackTrace();}/** El objeto cifrado es en realidad Operación de cifrado completada*/Cipher cipher = null;try {cipher = Cipher.getInstance("DES");} catch (NoSuchAlgorithmException e) {e.printStackTrace();} catch (NoSuchPaddingException e) {e.printStackTrace();}/** Inicializar el objeto Cipher con clave*/try {cipher.init(Cipher.DECRYPT_MODE, key, sr);} catch (InvalidKeyException e) {e.printStackTrace();}/** Ejecución formal de la operación de descifrado*/byte decryptedData[] = null;try {decryptedData = cipher.doFinal(encryptedData);} captura (IllegalStateException e) {e.printStackTrace();} captura (IllegalBlockSizeException e) {e.printStackTrace();} captura (BadPaddingException e) {e.printStackTrace();} devolver datos descifrados;}/** * Este método para obtener la clave de seguridad no es válido porque cada vez que se genera la clave, la clave utilizada para el descifrado y el cifrado es diferente, lo que genera el error Dado el bloque final no * rellenado correctamente * * @return byte array* @author Song. Lijun* @ fecha 3 de julio de 2014*/byte privado[] getKey() {/** El algoritmo DES requiere una fuente de números aleatorios confiable*/SecureRandom sr = new SecureRandom();/** Genere un objeto generador de claves para el algoritmo DES de nuestra elección */KeyGenerator kg = null;try {kg = KeyGenerator.getInstance("DES");} catch (NoSuchAlgorithmException e) {e.printStackTrace();}kg.init ( sr);/** Generar clase de herramienta clave*/SecretKey key = kg.generateKey();/** Generar matriz de bytes clave*/byte rawKeyData[] = key.getEncoded();return rawKeyData;}}2. Cifrado y descifrado Base64
paquete com.itjh.javaUtil;import java.io.*;/** * Codificación y decodificación Base64. * * @author Song Lijun* @fecha 3 de julio de 2014*/public class Base64 {public Base64() {}/** * Función: cadena codificada* * @author Song Lijun* @fecha 3 de julio de 2014* @param data * Cadena de origen* @return String */codificación de cadena estática pública (datos de cadena) {return new String(encode(data.getBytes()));}/** * Función: decodificar cadena* * @author Song Lijun* @fecha 3 de julio de 2014* @param data * cadena fuente* @return String */public static String decode(String data) {return new String(decode(data .toCharArray( )));}/** * Función: byte de codificación[] * * @author Song Lijun* @fecha 3 de julio de 2014* @param data * fuente* @return char[] */public static char[] codificar(byte[] datos) {char[] out = new char[((data.length + 2) / 3) * 4];for (int i = 0, índice = 0; i < data.length; i += 3, índice += 4) {boolean quad = false;boolean trip = false;int val = (0xFF & (int) data[i]);val <<= 8;si ((i + 1) < datos.longitud) {val |= (0xFF & (int) datos[i + 1]);viaje = verdadero;}val <<= 8;si ((i + 2) < data.length) {val |= (0xFF & (int) data[i + 2]);quad = true;}out[index + 3] = alfabeto[(quad ? (val & 0x3F) : 64)];val >>= 6;salida[índice + 2] = alfabeto[(viaje ? (val & 0x3F): 64)];val >>= 6;salida[índice + 1] = alfabeto[val & 0x3F ];val >>= 6;out[index + 0] = alfabeto[val & 0x3F];}return out;}/** * Función: decodificar* * @author Song Lijun* @fecha 3 de julio de 2014* @param data * Matriz de caracteres codificados* @return byte[] */public static byte[] decode(char[] data) {int tempLen = data.length;for ( int ix = 0; ix < datos.longitud; ix++) {si ((datos[ix] > 255) || códigos[datos[ix]] < 0) {--tempLen; // ignora los caracteres y el relleno no válidos}}// calcula la longitud requerida:// - 3 bytes por cada 4 caracteres base64 válidos// - más 2 bytes si hay 3 caracteres base64 adicionales,/ / o más 1 byte si hay 2 extra.int len = (tempLen / 4) * 3;if ((tempLen % 4) == 3) {len += 2;}if ((tempLen % 4) == 2) {len += 1;}byte[] out = new byte[len];int shift = 0; // # de bits sobrantes almacenados en accumint accum = 0; // exceso de bitsint index = 0;// ahora revisamos toda la matriz (NO usando el valor 'tempLen')for (int ix = 0; ix < data.length; ix++) {int value = (datos[ix] > 255) ? -1: códigos[datos[ix]];if (valor >= 0) { // omitir la acumulación sin código <<= 6 // los bits aumentan en 6 cada vez que se realiza el cambio; += 6; // bucle, con nuevos bits colocados en accum |= valor; // en la parte inferior.if (shift >= 8) { // siempre que haya 8 o más desplazados,shift -= 8; escríbalos (de la parte superior, dejando anyout[index++] = // exceso en la parte inferior para la siguiente iteración.(byte) ((accum >> shift) & 0xff);}}}// si TODAVÍA hay algo incorrecto, solo tenemos que vomitar ahora!if (index != out.length) {throw new Error("Longitud de datos mal calculada (escribió " + index+ " en lugar de " + out.length + ")");}return out;}/** * Función: Codificar archivo* * @author Song Lijun* @fecha 3 de julio de 2014* @param archivo * Archivo fuente*/codificación pública estática vacía (archivo de archivo) lanza IOException {if (!file.exists()) {System. (0);}else {byte[] decodificado = readBytes(archivo);char[] codificado = codificar(decodificado);writeChars(archivo, codificado);}archivo = null;}/** * Función: Decodificar archivos. * * @author Song Lijun* @fecha 3 de julio de 2014* @param archivo * Archivo fuente* @throws IOException */public static void decode(Archivo de archivo) lanza IOException {if (!file.exists()) {System. (0);} else {char[] codificado = readChars(archivo);byte[] decodificado = decodificar(codificado);writeBytes(archivo, decodificado);}archivo = nulo;}//// caracteres de código para valores 0..63//carácter estático privado[] alfabeto = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();//// tabla de búsqueda para convertir caracteres base64 para valorar en el rango 0..63//byte estático privado[] códigos = nuevo byte[256];static {for (int i = 0; i < 256; i++) {codes[i] = -1;// LoggerUtil.debug(i + "&" + códigos[i] + " ");}for (int i = 'A'; i <= 'Z'; i++) {códigos[i] = (byte) (i - 'A');// LoggerUtil.debug(i + "&" + códigos[i] + " ");}for (int i = 'a'; i <= 'z'; i++) {códigos[i] = (byte) (26 + i - 'a');// LoggerUtil.debug(i + "&" + códigos[i] + " ");}for (int i = '0'; i <= '9 '; yo++) {códigos[i] = (byte) (52 + i - '0');// LoggerUtil.debug(i + "&" + códigos[i] + " ");}códigos['+'] = 62; códigos ['/'] = 63;} byte estático privado [] readBytes (archivo) lanza IOException {ByteArrayOutputStream baos = nuevo ByteArrayOutputStream();byte[] b = nulo;InputStream fis = nulo;InputStream es = nulo;pruebe {fis = nuevo FileInputStream(archivo);es = nuevo BufferedInputStream(fis);int count = 0;byte[] buf = nuevo byte[16384]; while ((count = is.read(buf)) != -1) {if (count > 0) {baos.write(buf, 0, count);}}b = baos.toByteArray();} finalmente {intenta {if (fis != null)fis.close();if (is != null)is.close ();if (baos != null)baos.close();} catch (Excepción e) {System.out.println(e);}}return b;}carácter estático privado[] readChars(Archivo) lanza IOException {CharArrayWriter caw = new CharArrayWriter();Reader fr = null;Reader in = null;try {fr = new FileReader(file);in = new BufferedReader(fr);int count = 0;char [] buf = nuevo char[16384]; while ((count = in.read(buf)) != -1) {if (count > 0) {caw.write(buf, 0, count);}}} finalmente {intenta {if (caw != null)caw.close();if (in != null)in.close();if (fr != null)fr.close();} catch (Excepción e) {System.out.println(e);}}return caw.toCharArray();}writeBytes vacíos estáticos privados (archivo de archivo, byte[] datos) lanza IOException {OutputStream fos = null;OutputStream os = null;try {fos = new FileOutputStream(file);os = new BufferedOutputStream(fos);os.write(data);} finalmente {try {if ( os != null)os.close();if (fos != null)fos.close();} captura (Excepción e) {System.out.println(e);}}}writeChars vacío estático privado (archivo, datos char[]) lanza IOException {Writer fos = null;Writer os = null;try {fos = new FileWriter(file);os = nuevo BufferedWriter(fos);os.write(data);} finalmente {intenta {if (os != null)os.close();if (fos != null)fos.close();} catch (Excepción e) {e.printStackTrace();}}}// //////////////////////// / ///////////////////////////// fin del código de prueba.// ////////////////////////////////////////////////// ///}PD: con respecto a la tecnología de cifrado, este sitio también proporciona las siguientes herramientas de cifrado para su referencia:
Herramienta de codificación y decodificación BASE64: http://tools.VeVB.COm/transcoding/base64
Herramienta de cifrado en línea MD5: http://tools.VeVB.COm/password/CreateMD5Password
Herramienta de cifrado/descifrado de escape: http://tools.VeVB.COm/password/escapepwd
Herramienta de cifrado SHA1 en línea: http://tools.VeVB.COm/password/sha1encode
Herramienta de generación en línea de enlaces cortos (URL corta): http://tools.VeVB.COm/password/dwzcreate
Herramienta de restauración en línea de enlace corto (URL corta): http://tools.VeVB.COm/password/unshorturl
Generador de contraseñas seguras: http://tools.VeVB.COm/password/CreateStrongPassword