Los algoritmos de cifrado simples en Java son:
- BASE64, estrictamente hablando, pertenece a un formato de codificación, no a un algoritmo de cifrado.
- MD5 (Message Digest Algorithm 5, algoritmo de resumen de información)
- SHA (Secure Hash Algorithm, algoritmo de hash seguro)
- HMAC (Hash Message Authentication Code, código de autenticación de mensajes hash)
1. BASE64
Base64 es uno de los métodos de codificación más comunes en la red para transmitir código de bytes de 8 bits. Pueden consultar RFC2045~RFC2049, donde se encuentran las especificaciones detalladas de MIME. La codificación Base64 se puede utilizar para transmitir información de identificación larga en entornos HTTP. Por ejemplo, en el sistema de persistencia de Java Hibernate, se utiliza Base64 para codificar un identificador único largo (generalmente un UUID de 128 bits) como una cadena, que se usa como parámetro en formularios HTTP y URLs GET de HTTP. En otras aplicaciones, también es frecuente la necesidad de codificar datos binarios en una forma adecuada para colocarlos en URLs (incluidos campos de formulario ocultos). En este caso, la codificación Base64 tiene la característica de no ser legible, es decir, los datos codificados no pueden ser vistos directamente por el ojo humano. (Fuente: Baidu Baike)
Código de implementación en Java:
package com.cn.单向加密;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/*
BASE64的加密解密是双向的，可以求反解.
BASE64Encoder和BASE64Decoder是非官方JDK实现类。虽然可以在JDK里能找到并使用，但是在API里查不到。
JRE 中 sun 和 com.sun 开头包的类都是未被文档化的，他们属于 java, javax 类库的基础，其中的实现大多数与底层平台有关，
一般来说是不推荐使用的。
BASE64 严格地说，属于编码格式，而非加密算法
主要就是BASE64Encoder、BASE64Decoder两个类，我们只需要知道使用对应的方法即可。
另，BASE加密后产生的字节位数是8的倍数，如果不够位数以=符号填充。
BASE64
按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。
（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）
常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。
*/
public class BASE64 {
/**
* BASE64解密
*
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptBASE64(String key) throws Exception {
return (new BASE64Decoder()).decodeBuffer(key);
}
/**
* BASE64加密
*
* @param key
* @return
* @throws Exception
*/
public static String encryptBASE64(byte[] key) throws Exception {
return (new BASE64Encoder()).encodeBuffer(key);
}
public static void main(String[] args) {
String str="12345678";
try {
String result1= BASE64.encryptBASE64(str.getBytes());
System.out.println("result1=====加密数据=========="+result1);
byte result2[]= BASE64.decryptBASE64(result1);
String str2=new String(result2);
System.out.println("str2========解密数据========"+str2);
} catch (Exception e) {
e.printStackTrace();
}
}
}
2. MD5
MD5Es decir, Message-Digest Algorithm 5 (algoritmo de resumen de información 5), se utiliza para garantizar la integridad y consistencia de la transmisión de información. Es uno de los algoritmos hash ampliamente utilizados en computación (también traducido como algoritmo de resumen o algoritmo hash). Los lenguajes de programación convencionales ya tienen implementaciones de MD5. Transformar datos (como caracteres chinos) en otro valor de longitud fija es el principio básico de los algoritmos hash. Los predecesores de MD5 incluyen MD2, MD3y MD4. Se utiliza ampliamente en técnicas de cifrado y descifrado, y comúnmente en la verificación de archivos. ¿Verificación? Sin importar cuán grande sea el archivo, después de MD5 se puede generar un valor MD5 único. Por ejemplo, las verificaciones ISO actuales son todas verificaciones MD5. ¿Cómo se usa? Por supuesto, se aplica MD5 al ISO para producir el valor MD5. Quienes descargan ISO de Linux generalmente ven la cadena MD5 junto al enlace de descarga. Se usa para verificar si el archivo es consistente.
Código de implementación en Java:
package com.cn.单向加密;
import java.math.BigInteger;
import java.security.MessageDigest;
/*
MD5(Message Digest algorithm 5，信息摘要算法)
通常我们不直接使用上述MD5加密。通常将MD5产生的字节数组交给BASE64再加密一把，得到相应的字符串
Digest:汇编
*/
public class MD5 {
public static final String KEY_MD5 = "MD5";
public static String getResult(String inputStr)
{
System.out.println("=======加密前的数据:"+inputStr);
BigInteger bigInteger=null;
try {
MessageDigest md = MessageDigest.getInstance(KEY_MD5);
byte[] inputData = inputStr.getBytes();
md.update(inputData);
bigInteger = new BigInteger(md.digest());
} catch (Exception e) {e.printStackTrace();}
System.out.println("MD5加密后:" + bigInteger.toString(16));
return bigInteger.toString(16);
}
public static void main(String args[])
{
try {
String inputStr = "简单加密8888888888888888888";
getResult(inputStr);
} catch (Exception e) {
e.printStackTrace();
}
}
}
El algoritmo MD5 tiene las siguientes características:
1. Compresión: para datos de cualquier longitud, el valor MD5 calculado siempre tiene una longitud fija.
2. Fácil de calcular: es muy fácil calcular el valor MD5 a partir de los datos originales.
3. Resistencia a modificaciones: cualquier cambio en los datos originales, incluso de solo 1 byte, produce una gran diferencia en el valor MD5 resultante.
4. Débil resistencia a colisiones: conociendo los datos originales y su valor MD5, encontrar un dato con el mismo valor MD5 (es decir, datos falsificados) es muy difícil.
5. Fuerte resistencia a colisiones: encontrar dos datos diferentes que tengan el mismo valor MD5 es muy difícil.
La función de MD5 es "comprimir" información de gran capacidad en un formato confidencial antes de firmar con software de firma digital una clave privada (es decir, transformar una cadena de bytes de cualquier longitud en una cadena de dígitos hexadecimales de longitud fija). Además de MD5, también son conocidos SHA-1, RIPEMD y Haval, entre otros.
3.SHA
El algoritmo de hash seguro (Secure Hash Algorithm) se aplica principalmente al algoritmo de firma digital (Digital Signature Algorithm, DSA) definido en el estándar de firma digital (Digital Signature Standard, DSS). Para mensajes de longitud menor a 2^64 bits, SHA-1 produce un resumen de mensaje de 160 bits. Este algoritmo ha sido desarrollado y mejorado por expertos en criptografía durante años, volviéndose cada vez más completo y ampliamente utilizado. La idea del algoritmo es recibir un texto plano y convertirlo de manera irreversible en un texto cifrado (generalmente más pequeño). También puede entenderse simplemente como el proceso de tomar una cadena de entrada (llamada preimagen o información) y transformarla en una secuencia de salida más corta y de bits fijos, es decir, el valor hash (también llamado resumen de información o código de autenticación de información). El valor de la función hash puede considerarse una "huella digital" o un "resumen" del texto plano, por lo que la firma digital del valor hash puede verse como la firma digital del texto plano.
Código de implementación en Java:
package com.cn.单向加密;
import java.math.BigInteger;
import java.security.MessageDigest;
/*
SHA(Secure Hash Algorithm，安全散列算法），数字签名等密码学应用中重要的工具，
被广泛地应用于电子商务等信息安全领域。虽然，SHA与MD5通过碰撞法都被破解了，
但是SHA仍然是公认的安全加密算法，较之MD5更为安全*/
public class SHA {
public static final String KEY_SHA = "SHA";
public static String getResult(String inputStr)
{
BigInteger sha =null;
System.out.println("=======加密前的数据:"+inputStr);
byte[] inputData = inputStr.getBytes();
try {
MessageDigest messageDigest = MessageDigest.getInstance(KEY_SHA);
messageDigest.update(inputData);
sha = new BigInteger(messageDigest.digest());
System.out.println("SHA加密后:" + sha.toString(32));
} catch (Exception e) {e.printStackTrace();}
return sha.toString(32);
}
public static void main(String args[])
{
try {
String inputStr = "简单加密";
getResult(inputStr);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Comparación entre SHA-1 y MD5
Debido a que ambos derivan de MD4, SHA-1 y MD5 son muy similares entre sí. En consecuencia, su fortaleza y otras características también son similares, pero aún existen las siguientes diferencias:
l Seguridad contra ataques de fuerza bruta: la diferencia más notable e importante es que el resumen SHA-1 es 32 bits más largo que el resumen MD5. Con técnicas de fuerza bruta, la dificultad de producir un mensaje cuyo resumen sea igual al resumen de un mensaje dado es del orden de 2^128 operaciones para MD5, mientras que para SHA-1 es del orden de 2^160 operaciones. Así, SHA-1 tiene mayor fortaleza contra ataques de fuerza bruta.
l Seguridad contra criptoanálisis: debido al diseño de MD5, es vulnerable a ataques de criptoanálisis; SHA-1 parece no ser tan susceptible a tales ataques.
l Velocidad: en el mismo hardware, SHA-1 es más lento que MD5.
4.HMAC
HMAC (Hash Message Authentication Code, código de autenticación de mensajes hash, protocolo de autenticación basado en algoritmo hash con clave. El principio de autenticación del código de autenticación de mensajes es usar una función pública y una clave para generar un valor de longitud fija como identificador de autenticación, y usar este identificador para verificar la integridad del mensaje. Se utiliza una clave para generar un pequeño bloque de datos de tamaño fijo, es decir, el MAC, que se agrega al mensaje y luego se transmite. El receptor utiliza la clave compartida con el emisor para realizar la autenticación, etc.
Código de implementación en Java:
package com.cn.单向加密;
/*
HMAC
HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。
消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。
使用一个密钥生成一个固定大小的小数据块，
即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。*/
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import com.cn.comm.Tools;
/**
* 基础加密组件
*/
public abstract class HMAC {
public static final String KEY_MAC = "HmacMD5";
/**
* 初始化HMAC密钥
*
* @return
* @throws Exception
*/
public static String initMacKey() throws Exception {
KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
SecretKey secretKey = keyGenerator.generateKey();
return BASE64.encryptBASE64(secretKey.getEncoded());
}
/**
* HMAC加密 ：主要方法
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static String encryptHMAC(byte[] data, String key) throws Exception {
SecretKey secretKey = new SecretKeySpec(BASE64.decryptBASE64(key), KEY_MAC);
Mac mac = Mac.getInstance(secretKey.getAlgorithm());
mac.init(secretKey);
return new String(mac.doFinal(data));
}
public static String getResult1(String inputStr)
{
String path=Tools.getClassPath();
String fileSource=path+"/file/HMAC_key.txt";
System.out.println("=======加密前的数据:"+inputStr);
String result=null;
try {
byte[] inputData = inputStr.getBytes();
String key = HMAC.initMacKey(); /*产生密钥*/
System.out.println("Mac密钥:===" + key);
/*将密钥写文件*/
Tools.WriteMyFile(fileSource,key);
result= HMAC.encryptHMAC(inputData, key);
System.out.println("HMAC加密后:===" + result);
} catch (Exception e) {e.printStackTrace();}
return result.toString();
}
public static String getResult2(String inputStr)
{
System.out.println("=======加密前的数据:"+inputStr);
String path=Tools.getClassPath();
String fileSource=path+"/file/HMAC_key.txt";
String key=null;;
try {
/*将密钥从文件中读取*/
key=Tools.ReadMyFile(fileSource);
System.out.println("getResult2密钥:===" + key);
} catch (Exception e1) {
e1.printStackTrace();}
String result=null;
try {
byte[] inputData = inputStr.getBytes();
/*对数据进行加密*/
result= HMAC.encryptHMAC(inputData, key);
System.out.println("HMAC加密后:===" + result);
} catch (Exception e) {e.printStackTrace();}
return result.toString();
}
public static void main(String args[])
{
try {
String inputStr = "简单加密";
/*使用同一密钥：对数据进行加密：查看两次加密的结果是否一样*/
getResult1(inputStr);
getResult2(inputStr);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Fuente: http://www.cnblogs.com/oumyye/p/4593592.html