Les algorithmes de chiffrement Java simples incluent :
- BASE64, à proprement parler, est un format d'encodage, et non un algorithme de chiffrement
- MD5 (Message Digest Algorithm 5, algorithme de résumé d'informations)
- SHA (Secure Hash Algorithm, algorithme de hachage sécurisé)
- HMAC (Hash Message Authentication Code, code d'authentification de message par hachage)
1. BASE64
Base64 est l'une des méthodes d'encodage les plus courantes utilisées sur le réseau pour transmettre du code d'octets 8 bits. Vous pouvez vous référer à la RFC2045~RFC2049, qui contient les spécifications détaillées de MIME. L'encodage Base64 peut être utilisé pour transmettre des informations d'identification plus longues dans l'environnement HTTP. Par exemple, dans le système Java Persistence Hibernate, Base64 est utilisé pour encoder un identifiant unique plus long (généralement un UUID de 128 bits) en une chaîne, utilisée comme paramètre dans les formulaires HTTP et les URL HTTP GET. Dans d'autres applications, il est aussi souvent nécessaire d'encoder des données binaires sous une forme adaptée à une insertion dans des URL (y compris des champs de formulaire cachés). Dans ce cas, l'encodage Base64 est illisible, ce qui signifie que les données encodées ne peuvent pas être directement vues à l'œil nu. (Source : Baidu Baike)
Code d'implémentation 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
MD5C'est-à-dire Message-Digest Algorithm 5 (algorithme de résumé d'informations 5), utilisé pour garantir une transmission d'informations complète et cohérente. C'est l'un des algorithmes de hachage les plus utilisés en informatique (également traduit par algorithme de résumé, algorithme de hachage), et les langages de programmation courants disposent généralement déjà d'implémentations de MD5. Calculer des données (telles que des caractères chinois) en une autre valeur de longueur fixe est le principe de base des algorithmes de hachage. Les prédécesseurs de MD5 incluent MD2, MD3et MD4. Il est largement utilisé dans les technologies de chiffrement et de déchiffrement, souvent pour la vérification de fichiers. Vérification ? Peu importe la taille du fichier, une valeur MD5 unique peut être générée après hachage MD5. Par exemple, la vérification ISO actuelle est entièrement une vérification MD5. Comment est-il utilisé ? Bien sûr, l'ISO est traité avec MD5 pour produire une valeur MD5. Ceux qui téléchargent des fichiers ISO Linux ont généralement vu une chaîne MD5 à côté du lien de téléchargement. Elle sert à vérifier si le fichier est cohérent.
Code d'implémentation 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();
}
}
}
L'algorithme MD5 présente les caractéristiques suivantes :
1. Compressibilité : Pour des données de toute longueur, la longueur de la valeur MD5 calculée est fixe.
2. Facile à calculer : il est facile de calculer la valeur MD5 à partir des données d'origine.
3. Résistance à la modification : toute modification des données d'origine, même ne portant que sur 1 octet, produira une valeur MD5 très différente.
4. Faible résistance aux collisions : étant donné les données d'origine et leur valeur MD5, il est très difficile de trouver des données (c'est-à-dire des données falsifiées) ayant la même valeur MD5.
5. Forte résistance aux collisions : il est très difficile de trouver deux données différentes ayant la même valeur MD5.
La fonction de MD5 est de « compresser » des informations volumineuses dans un format secret avant de signer une clé privée avec un logiciel de signature numérique (c'est-à-dire transformer une chaîne d'octets de longueur arbitraire en une chaîne de chiffres hexadécimaux de longueur fixe). Outre MD5, d'autres algorithmes bien connus incluent sha-1, RIPEMD et Haval, etc.
3.SHA
L'algorithme de hachage sécurisé (SHA) s'applique principalement à l'algorithme de signature numérique (Digital Signature Algorithm, DSA) défini dans la norme de signature numérique (Digital Signature Standard, DSS). Pour les messages d'une longueur inférieure à 2^64 bits, SHA1 produit un condensé de message de 160 bits. Après des années de développement et d'amélioration par des experts en chiffrement, cet algorithme est devenu de plus en plus parfait et est largement utilisé. L'idée de l'algorithme est de recevoir un texte en clair puis de le convertir en un texte chiffré (généralement plus petit) de manière irréversible. Il peut aussi être simplement compris comme le processus consistant à prendre une chaîne de codes d'entrée (appelée pré-mappage ou information) et à la convertir en une séquence de sortie plus courte et à nombre de bits fixe, c'est-à-dire une valeur de hachage (aussi appelée condensé d'information ou code d'authentification de message). On peut dire que la valeur de la fonction de hachage est une « empreinte » ou un « condensé » du texte en clair, de sorte qu'une signature numérique sur la valeur de hachage peut être considérée comme une signature numérique sur ce texte en clair.
Code d'implémentation 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();
}
}
}
Comparaison entre SHA-1 et MD5
Comme tous deux dérivent de MD4, SHA-1 et MD5 sont très similaires l’un à l’autre. En conséquence, leur robustesse et leurs autres caractéristiques sont également similaires, mais il existe les différences suivantes :
l Sécurité contre les attaques par force brute : La différence la plus significative et importante est que le condensat SHA-1 est 32 bits plus long que le condensat MD5. En utilisant des techniques de force brute, la difficulté de produire un message dont le condensat est égal à un condensat de message donné est de l’ordre de 2^128 opérations pour MD5, et de l’ordre de 2^160 opérations pour SHA-1. Ainsi, SHA-1 offre une plus grande robustesse contre les attaques par force brute.
l Sécurité contre la cryptanalyse : En raison de la conception de MD5, il est vulnérable aux attaques cryptanalytiques ; SHA-1 semble moins sensible à de telles attaques.
l Vitesse : Sur le même matériel, SHA-1 s’exécute plus lentement que MD5.
4.HMAC
HMAC (Hash Message Authentication Code, code d’authentification de message par hachage) est un protocole d’authentification basé sur un algorithme de hachage à clé. Le principe de mise en œuvre d’un code d’authentification de message consiste à utiliser une fonction publique et une clé pour générer une valeur de longueur fixe comme identifiant d’authentification, et à utiliser cet identifiant pour authentifier l’intégrité du message. Une clé est utilisée pour générer un petit bloc de données de taille fixe, à savoir le MAC, qui est ajouté au message puis transmis. Le destinataire utilise la clé partagée avec l’expéditeur pour l’identification et l’authentification, etc.
Code d'implémentation 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();
}
}
}
Source : http://www.cnblogs.com/oumyye/p/4593592.html