Partagez plusieurs algorithmes de chiffrement couramment utilisés en Java (quatre types)

L'algorithme de chiffrement symétrique est un algorithme de chiffrement antérieur doté d'une technologie mature. Dans l'algorithme de chiffrement symétrique, l'expéditeur des données traite le texte en clair (données originales) et la clé de chiffrement (mi yue) avec un algorithme de chiffrement spécial, les transformant en texte chiffré complexe et les envoyant. Une fois que le destinataire a reçu le texte chiffré, s'il souhaite déchiffrer le texte original, il doit utiliser la clé utilisée pour le cryptage et l'algorithme inverse du même algorithme pour déchiffrer le texte chiffré afin de le restaurer en texte clair lisible. Dans l'algorithme de chiffrement symétrique, une seule clé est utilisée. L'expéditeur et le destinataire utilisent cette clé pour chiffrer et déchiffrer les données. Cela nécessite que le déchiffreur connaisse la clé de chiffrement à l'avance.

Les algorithmes de chiffrement Java simples sont :

BASE À proprement parler, il s'agit d'un format de codage, pas d'un algorithme de chiffrement
MD (algorithme de résumé de message, algorithme de résumé de message)
SHA( Algorithme de hachage sécurisé, algorithme de hachage sécurisé)
HMAC (Hash Message Authentication Code, code d'authentification du message de hachage)

Le premier BASE

Base est le plus populaire sur. Internet L'une des méthodes de codage courantes utilisées pour transmettre du code bit-octet, vous pouvez consulter RFC~RFC, qui contient des spécifications détaillées de MIME. Le codage de base peut être utilisé pour transmettre des informations d'identification plus longues dans un environnement HTTP. Par exemple, dans le système Java Persistence Hibernate, Base est utilisé pour coder un long identifiant unique (généralement un UUID de -bit) dans une chaîne, qui est utilisée comme paramètres dans les formulaires HTTP et les URL HTTP GET. Dans d'autres applications, il est souvent nécessaire d'encoder les données binaires sous une forme adaptée au placement dans une URL (y compris les champs de formulaire masqués). À l’heure actuelle, le codage de base est illisible, c’est-à-dire que les données codées ne seront pas directement visibles à l’œil nu. (Source Encyclopédie Baidu)

Code d'implémentation Java :

package com.cn.单向加密;
import sun.misc.BASEDecoder;
import sun.misc.BASEEncoder;
/*
BASE的加密解密是双向的，可以求反解.
BASEEncoder和BASEDecoder是非官方JDK实现类。虽然可以在JDK里能找到并使用，但是在API里查不到。
JRE 中 sun 和 com.sun 开头包的类都是未被文档化的，他们属于 java, javax 类库的基础，其中的实现大多数与底层平台有关，
一般来说是不推荐使用的。
BASE 严格地说，属于编码格式，而非加密算法
主要就是BASEEncoder、BASEDecoder两个类，我们只需要知道使用对应的方法即可。
另，BASE加密后产生的字节位数是的倍数，如果不够位数以=符号填充。
BASE
按照RFC的定义，Base被定义为：Base内容传送编码被设计用来把任意序列的位字节描述为一种不易被人直接识别的形式。
（The Base Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）
常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE加密的。
*/
public class BASE {
  /**
   * BASE解密
   *
   * @param key
   * @return
   * @throws Exception
   */
  public static byte[] decryptBASE(String key) throws Exception {
    return (new BASEDecoder()).decodeBuffer(key);
  }
  /**
   * BASE加密
   *
   * @param key
   * @return
   * @throws Exception
   */
  public static String encryptBASE(byte[] key) throws Exception {
    return (new BASEEncoder()).encodeBuffer(key);
  }
  public static void main(String[] args) {
   String str="";
    try {
    String result= BASE.encryptBASE(str.getBytes());
     System.out.println("result=====加密数据=========="+result);
     byte result[]= BASE.decryptBASE(result);
     String str=new String(result);
     System.out.println("str========解密数据========"+str);
  } catch (Exception e) {
    e.printStackTrace();
  }
  }
}

Le deuxième type MD

MD est Message. -Digest Algorithm (algorithme de digestion d'informations), utilisé pour assurer une transmission complète et cohérente des informations. Il s'agit de l'un des algorithmes de hachage largement utilisés dans les ordinateurs (également traduit par algorithme de résumé et algorithme de hachage). MD a été généralement implémenté dans les langages de programmation traditionnels. Le calcul des données (telles que les caractères chinois) dans une autre valeur de longueur fixe est le principe de base de l'algorithme de hachage. Les prédécesseurs de MD sont MD, MD et MD. Largement utilisé dans la technologie de cryptage et de décryptage, souvent utilisé pour la vérification de fichiers. vérifier? Quelle que soit la taille du fichier, une valeur MD unique peut être générée après MD. Par exemple, l'étalonnage ISO actuel est l'étalonnage MD. Comment l'utiliser ? Bien entendu, la valeur MD est générée après le passage de l'ISO via MD. Généralement, les amis qui ont téléchargé Linux-ISO ont vu la chaîne MD à côté du lien de téléchargement. Il permet de vérifier si les fichiers sont cohérents.

implémentation Java :

package com.cn.单向加密;
import java.math.BigInteger;
import java.security.MessageDigest;
/*
MD(Message Digest algorithm ，信息摘要算法)
通常我们不直接使用上述MD加密。通常将MD产生的字节数组交给BASE再加密一把，得到相应的字符串
Digest:汇编
*/
public class MD {
  public static final String KEY_MD = "MD";
  public static String getResult(String inputStr)
  {
    System.out.println("=======加密前的数据:"+inputStr);
    BigInteger bigInteger=null;
    try {
     MessageDigest md = MessageDigest.getInstance(KEY_MD);
     byte[] inputData = inputStr.getBytes();
     md.update(inputData);
     bigInteger = new BigInteger(md.digest());
    } catch (Exception e) {e.printStackTrace();}
    System.out.println("MD加密后:" + bigInteger.toString());
    return bigInteger.toString();
  }
  public static void main(String args[])
  {
    try {
       String inputStr = "简单加密";
       getResult(inputStr);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

L'algorithme MD a les caractéristiques suivantes :

, compression : données de n'importe quelle longueur , la longueur de la valeur MD calculée est fixe.
.Facile à calculer : il est facile de calculer la valeur MD à partir des données originales.
. Résistance à la modification : si des modifications sont apportées aux données d'origine, même si un seul octet est modifié, la valeur MD résultante sera très différente.
, Faible anti-collision : Connaissant les données originales et leur valeur MD, il est très difficile de trouver des données avec la même valeur MD (c'est-à-dire des données falsifiées).
, Forte anti-collision : Il est très difficile de trouver deux données différentes pour qu'elles aient la même valeur MD.

La fonction de MD est de permettre à des informations de grande capacité d'être « compressées » dans un format confidentiel avant de signer la clé privée avec un logiciel de signature numérique (c'est-à-dire convertir une chaîne d'octets de n'importe quelle longueur en une certaine longueur chaîne de seize chiffres hexadécimaux). Outre MD, les plus célèbres sont sha-, RIPEMD et Haval.

Le troisième type. SHA

L'algorithme de hachage sécurisé est principalement applicable à l'algorithme de signature numérique DSA défini dans la norme de signature numérique DSS. Pour les messages d'une longueur inférieure à ^ bits, SHA produit un résumé de message d'un bit. Cet algorithme a été développé et amélioré par des experts en chiffrement au fil des années et est de plus en plus perfectionné et largement utilisé. L'idée de cet algorithme est de recevoir un morceau de texte en clair, puis de le convertir en un morceau de texte chiffré (généralement plus petit) de manière irréversible. Cela peut également être simplement compris comme la prise d'une chaîne de codes d'entrée (appelée pré-mappage). ou informations), et Le processus de conversion de ceux-ci en une séquence de sortie plus courte à chiffres fixes, c'est-à-dire une valeur de hachage (également appelée résumé de message ou code d'authentification de message). La valeur de la fonction de hachage peut être considérée comme une « empreinte digitale » ou un « résumé » du texte en clair, de sorte que la signature numérique de la valeur de hachage peut être considérée comme la signature numérique du texte en clair.

Implémentation Java :

package com.cn.单向加密;
import java.math.BigInteger;
import java.security.MessageDigest;
/*
SHA(Secure Hash Algorithm，安全散列算法），数字签名等密码学应用中重要的工具，
被广泛地应用于电子商务等信息安全领域。虽然，SHA与MD通过碰撞法都被破解了，
但是SHA仍然是公认的安全加密算法，较之MD更为安全*/
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());
    } catch (Exception e) {e.printStackTrace();}
    return sha.toString();
  }
  public static void main(String args[])
  {
    try {
       String inputStr = "简单加密";
       getResult(inputStr);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

Comparaison entre SHA- et MD

Parce que les deux sont exportés par MD, SHA - et MD sont très similaires. En conséquence, leurs points forts et autres caractéristiques sont similaires, mais il existe les différences suivantes :

Sécurité contre les attaques par force brute : La différence la plus significative et la plus importante est que le résumé SHA est plus long que le résumé MD. En utilisant des techniques de force brute, la difficulté de générer un message dont le résumé est égal à un résumé de message donné est une opération de l'ordre de grandeur pour MD et une opération de l'ordre de grandeur pour SHA-. De cette façon, SHA- a une plus grande force contre les attaques par force brute.

Sécurité contre la cryptanalyse : en raison de la conception de MD, il est vulnérable aux attaques de cryptanalyse, tandis que SHA- semble être moins vulnérable à de telles attaques.

Vitesse : SHA- fonctionne plus lentement que MD sur le même matériel.

Le quatrième type.HMAC

HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。

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 = "HmacMD";
  /**
   * 初始化HMAC密钥
   *
   * @return
   * @throws Exception
   */
  public static String initMacKey() throws Exception {
    KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
    SecretKey secretKey = keyGenerator.generateKey();
    return BASE.encryptBASE(secretKey.getEncoded());
  }
  /**
   * HMAC加密 ：主要方法
   *
   * @param data
   * @param key
   * @return
   * @throws Exception
   */
  public static String encryptHMAC(byte[] data, String key) throws Exception {
    SecretKey secretKey = new SecretKeySpec(BASE.decryptBASE(key), KEY_MAC);
    Mac mac = Mac.getInstance(secretKey.getAlgorithm());
    mac.init(secretKey);
    return new String(mac.doFinal(data));
  }
  public static String getResult(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 getResult(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("getResult密钥:===" + key);
    } catch (Exception e) {
      e.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 = "简单加密";
       /*使用同一密钥：对数据进行加密：查看两次加密的结果是否一样*/
       getResult(inputStr);
       getResult(inputStr);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

   

以上内容是小编给大家分享的Java常用几种加密算法(四种)，希望大家喜欢。

更多分享Java常用几种加密算法(四种)相关文章请关注PHP中文网！