Einfache Java-Verschlüsselungsalgorithmen umfassen:
- BASE64 ist streng genommen ein Codierungsformat, kein Verschlüsselungsalgorithmus
- MD5 (Message Digest Algorithm 5, Informations-Digest-Algorithmus)
- SHA (Secure Hash Algorithm, sicherer Hash-Algorithmus)
- HMAC (Hash Message Authentication Code, Hash-Nachrichten-Authentifizierungscode)
1. BASE64
Base64 ist eine der gebräuchlichsten Kodierungsmethoden im Netzwerk zur Übertragung von 8-Bit-Bytecode. Sie können RFC2045~RFC2049 konsultieren, die detaillierte Spezifikationen von MIME enthalten. Base64-Kodierung kann verwendet werden, um längere Identifikationsinformationen in der HTTP-Umgebung zu übermitteln. Zum Beispiel wird im Java-Persistenzsystem Hibernate Base64 verwendet, um eine längere eindeutige Kennung (normalerweise eine 128-Bit-UUID) in eine Zeichenkette zu kodieren, die als Parameter in HTTP-Formularen und HTTP-GET-URLs verwendet wird. In anderen Anwendungen ist es ebenfalls oft notwendig, Binärdaten in eine Form zu kodieren, die für die Platzierung in URLs (einschließlich versteckter Formularfelder) geeignet ist. In diesem Fall ist die Base64-Kodierung unlesbar, was bedeutet, dass die kodierten Daten nicht direkt mit bloßem Auge gesehen werden können. (Quelle: Baidu Baike)
Java-Implementierungscode:
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
MD5Das ist der Message-Digest Algorithm 5 (Informations-Digest-Algorithmus 5), der verwendet wird, um eine vollständige und konsistente Informationsübertragung zu gewährleisten. Er ist einer der weit verbreiteten Hash-Algorithmen in Computern (auch übersetzt als Digest-Algorithmus, Hash-Algorithmus), und gängige Programmiersprachen verfügen im Allgemeinen bereits über MD5-Implementierungen. Daten (wie chinesische Zeichen) in einen anderen Wert fester Länge zu berechnen, ist das Grundprinzip von Hash-Algorithmen. Zu den Vorgängern von MD5 gehören MD2, MD3und MD4. Er wird häufig in der Ver- und Entschlüsselungstechnik eingesetzt, oft zur Dateiverifizierung. Verifizierung? Egal wie groß die Datei ist, nach der MD5-Hashung kann ein eindeutiger MD5-Wert erzeugt werden. Beispielsweise ist die aktuelle ISO-Verifizierung vollständig MD5-Verifizierung. Wie wird sie verwendet? Natürlich wird das ISO mit MD5 verarbeitet, um einen MD5-Wert zu erzeugen. Freunde, die Linux-ISO-Dateien herunterladen, haben normalerweise neben dem Download-Link eine MD5-Zeichenkette gesehen. Sie wird verwendet, um zu überprüfen, ob die Datei konsistent ist.
Java-Implementierungscode:
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();
}
}
}
Der MD5-Algorithmus hat die folgenden Eigenschaften:
1. Komprimierbarkeit: Für Daten beliebiger Länge ist die Länge des berechneten MD5-Werts fest.
2. Einfach zu berechnen: Es ist einfach, den MD5-Wert aus den Originaldaten zu berechnen.
3. Änderungsresistenz: Jede Änderung an den Originaldaten, selbst wenn nur 1 Byte geändert wird, führt zu einem stark abweichenden MD5-Wert.
4. Schwache Kollisionsresistenz: Wenn die Originaldaten und ihr MD5-Wert gegeben sind, ist es sehr schwierig, einen Datensatz (d. h. gefälschte Daten) mit demselben MD5-Wert zu finden.
5. Starke Kollisionsresistenz: Es ist sehr schwierig, zwei verschiedene Daten zu finden, die denselben MD5-Wert haben.
Die Funktion von MD5 besteht darin, umfangreiche Informationen vor dem Signieren eines privaten Schlüssels mit digitaler Signatursoftware in ein geheimes Format zu „komprimieren“ (das heißt, eine Byte-Zeichenfolge beliebiger Länge in eine hexadezimale Zeichenfolge fester Länge umzuwandeln). Neben MD5 gibt es weitere bekannte wie sha-1, RIPEMD und Haval usw.
3.SHA
Der Secure Hash Algorithm (SHA) ist hauptsächlich auf den im Digital Signature Standard (DSS) definierten Digital Signature Algorithm (DSA) anwendbar. Für Nachrichten mit einer Länge von weniger als 2^64 Bits erzeugt SHA1 einen 160-Bit-Nachrichtendigest. Nach jahrelanger Entwicklung und Verbesserung durch Verschlüsselungsexperten ist dieser Algorithmus zunehmend perfekt geworden und weit verbreitet. Die Idee des Algorithmus besteht darin, einen Klartext zu empfangen und ihn dann auf irreversible Weise in einen (normalerweise kleineren) Geheimtext umzuwandeln. Er kann auch einfach als der Prozess verstanden werden, eine Zeichenfolge von Eingabecodes (Pre-Mapping oder Information genannt) zu nehmen und sie in eine kürzere Ausgabesequenz mit fester Bitlänge umzuwandeln, d. h. einen Hashwert (auch Informationsdigest oder Message Authentication Code genannt). Der Wert der Hashfunktion kann als „Fingerabdruck“ oder „Digest“ des Klartextes bezeichnet werden, sodass eine digitale Signatur über den Hashwert als digitale Signatur dieses Klartextes angesehen werden kann.
Java-Implementierungscode:
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();
}
}
}
Vergleich zwischen SHA-1 und MD5
Da beide von MD4 abgeleitet sind, sind SHA-1 und MD5 einander sehr ähnlich. Entsprechend sind auch ihre Stärke und andere Eigenschaften ähnlich, es gibt jedoch die folgenden Unterschiede:
Sicherheit gegen Brute-Force-Angriffe: Der signifikanteste und wichtigste Unterschied besteht darin, dass der SHA-1-Digest 32 Bits länger ist als der MD5-Digest. Unter Verwendung von Brute-Force-Techniken liegt die Schwierigkeit, irgendeine Nachricht zu erzeugen, deren Digest einem gegebenen Nachrichten-Digest entspricht, in der Größenordnung von 2^128 Operationen für MD5 und in der Größenordnung von 2^160 Operationen für SHA-1. Somit hat SHA-1 eine größere Stärke gegen Brute-Force-Angriffe.
Sicherheit gegen Kryptoanalyse: Aufgrund des Designs von MD5 ist es anfällig für kryptoanalytische Angriffe; SHA-1 scheint weniger anfällig für solche Angriffe zu sein.
Geschwindigkeit: Auf derselben Hardware läuft SHA-1 langsamer als MD5.
4.HMAC
HMAC (Hash Message Authentication Code, Hash-Nachrichtenauthentifizierungscode) ist ein Authentifizierungsprotokoll, das auf einem schlüsselbasierten Hash-Algorithmus basiert. Das Prinzip der Implementierung eines Nachrichtenauthentifizierungscodes besteht darin, eine öffentliche Funktion und einen Schlüssel zu verwenden, um einen Wert fester Länge als Authentifizierungskennung zu erzeugen und diese Kennung zur Authentifizierung der Integrität der Nachricht zu verwenden. Ein Schlüssel wird verwendet, um einen kleinen Datenblock fester Größe, nämlich MAC, zu erzeugen, der der Nachricht hinzugefügt und dann übertragen wird. Der Empfänger verwendet den mit dem Sender gemeinsam genutzten Schlüssel zur Identifizierung und Authentifizierung usw.
Java-Implementierungscode:
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();
}
}
}
Quelle: http://www.cnblogs.com/oumyye/p/4593592.html