Teilen Sie mehrere in Java häufig verwendete Verschlüsselungsalgorithmen (vier Typen).

Der symmetrische Verschlüsselungsalgorithmus ist ein früherer Verschlüsselungsalgorithmus mit ausgereifter Technologie. Beim symmetrischen Verschlüsselungsalgorithmus verarbeitet der Datensender den Klartext (Originaldaten) und den Verschlüsselungsschlüssel (mi yue) zusammen mit einem speziellen Verschlüsselungsalgorithmus, wandelt sie in komplexen verschlüsselten Chiffretext um und versendet ihn. Nachdem der Empfänger den Chiffretext erhalten hat und den Originaltext entschlüsseln möchte, muss er den für die Verschlüsselung verwendeten Schlüssel und den umgekehrten Algorithmus desselben Algorithmus verwenden, um den Chiffretext zu entschlüsseln und ihn in lesbaren Klartext wiederherzustellen. Beim symmetrischen Verschlüsselungsalgorithmus wird nur ein Schlüssel verwendet. Sowohl der Sender als auch der Empfänger verwenden diesen Schlüssel, um die Daten zu verschlüsseln und zu entschlüsseln.

Einfache Java-Verschlüsselungsalgorithmen sind:

BASE Streng genommen handelt es sich um ein Codierungsformat, nicht um einen Verschlüsselungsalgorithmus
MD (Message Digest-Algorithmus, Message Digest-Algorithmus)
SHA( Sicherer Hash-Algorithmus, sicherer Hash-Algorithmus)
HMAC (Hash Message Authentication Code, Hash Message Authentication Code)

BASE

Base ist das beliebteste Das Internet Eine der gebräuchlichsten Codierungsmethoden zur Übertragung von Bit-Byte-Code ist RFC~RFC, das detaillierte MIME-Spezifikationen enthält. Die Basiskodierung kann verwendet werden, um längere Identifikationsinformationen in einer HTTP-Umgebung zu übermitteln. Beispielsweise wird Base im Java-Persistenzsystem Hibernate verwendet, um einen langen eindeutigen Bezeichner (normalerweise eine -Bit-UUID) in eine Zeichenfolge zu kodieren, die als Parameter in HTTP-Formularen und HTTP-GET-URLs verwendet wird. In anderen Anwendungen ist es häufig erforderlich, Binärdaten in eine Form zu kodieren, die für die Platzierung in einer URL geeignet ist (einschließlich versteckter Formularfelder). Zu diesem Zeitpunkt ist die Basiskodierung nicht lesbar, d. h. die kodierten Daten sind mit bloßem Auge nicht direkt sichtbar. (Quelle Baidu Encyclopedia)

Java-Implementierungscode:

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();
  }
  }
}

Der zweite Typ MD

MD ist Nachricht -Digest-Algorithmus (Information-Digest-Algorithmus), der verwendet wird, um eine vollständige und konsistente Informationsübertragung sicherzustellen. Es handelt sich um einen der in Computern weit verbreiteten Hash-Algorithmen (auch als Digest-Algorithmus übersetzt und MD-Hash-Algorithmus wurde allgemein in gängigen Programmiersprachen implementiert). Das Grundprinzip des Hash-Algorithmus besteht darin, Daten (z. B. chinesische Schriftzeichen) in einen anderen Wert mit fester Länge zu konvertieren. Die Vorgänger von MD sind MD, MD und MD. Wird häufig in der Verschlüsselungs- und Entschlüsselungstechnologie verwendet und häufig zur Dateiüberprüfung verwendet. überprüfen? Unabhängig von der Größe der Datei kann nach MD ein eindeutiger MD-Wert generiert werden. Die aktuelle ISO-Kalibrierung ist beispielsweise die MD-Kalibrierung. Wie benutzt man es? Natürlich wird der MD-Wert generiert, nachdem ISO durch MD geleitet wurde. Freunde, die Linux-ISO heruntergeladen haben, haben im Allgemeinen die MD-Zeichenfolge neben dem Download-Link gesehen. Es wird verwendet, um zu überprüfen, ob die Dateien konsistent sind.

Java-Implementierung:

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();
    }
  }
}

MD-Algorithmus hat die folgenden Eigenschaften:

, Komprimierung: Daten beliebiger Länge , die Länge des berechneten MD-Wertes ist fest.
, Einfach zu berechnen: Der MD-Wert lässt sich leicht aus den Originaldaten berechnen.
Änderungsbeständigkeit: Wenn Änderungen an den Originaldaten vorgenommen werden, wird der resultierende MD-Wert sehr unterschiedlich sein, selbst wenn nur ein einzelnes Byte geändert wird.
, Schwache Antikollision: Wenn man die Originaldaten und ihren MD-Wert kennt, ist es sehr schwierig, Daten mit demselben MD-Wert (d. h. gefälschte Daten) zu finden.
, Starke Antikollision: Es ist sehr schwierig, zwei verschiedene Daten zu finden, sodass sie denselben MD-Wert haben.

Die Funktion von MD besteht darin, die „Komprimierung“ großer Informationen in ein vertrauliches Format zu ermöglichen, bevor der private Schlüssel mit digitaler Signatursoftware signiert wird (d. h. eine Bytefolge beliebiger Länge in eine bestimmte Länge umgewandelt wird). aus sechzehn hexadezimalen Ziffernfolgen). Zu den bekannteren gehören neben MD auch sha-, RIPEMD und Haval.

Der dritte Typ SHA

Sicherer Hash-Algorithmus ist hauptsächlich auf den im Digital Signature Standard DSS definierten digitalen Signaturalgorithmus anwendbar. Für Nachrichten mit einer Länge von weniger als ^ Bits erstellt SHA einen Ein-Bit-Nachrichtenauszug. Dieser Algorithmus wurde im Laufe der Jahre von Verschlüsselungsexperten entwickelt und verbessert und zunehmend perfektioniert und weit verbreitet eingesetzt. Die Idee dieses Algorithmus besteht darin, ein Stück Klartext zu empfangen und es dann auf irreversible Weise in ein Stück (normalerweise kleineren) Chiffretext umzuwandeln. Dies kann auch einfach so verstanden werden, dass eine Zeichenfolge von Eingabecodes verwendet wird (sogenanntes Pre-Mapping). oder Informationen) und der Prozess der Umwandlung in eine kurze Ausgabesequenz mit fester Ziffer, d. h. einen Hash-Wert (auch Nachrichten-Digest oder Nachrichtenauthentifizierungscode genannt). Der Hash-Funktionswert kann als „Fingerabdruck“ oder „Digest“ des Klartextes bezeichnet werden, sodass die digitale Signatur des Hash-Werts als digitale Signatur des Klartextes betrachtet werden kann.

Java-Implementierung:

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();
    }
  }
}

Vergleich zwischen SHA- und MD

Da beide von MD, SHA exportiert werden - und MD sind einander sehr ähnlich. Dementsprechend sind ihre Stärken und sonstigen Eigenschaften ähnlich, es gibt jedoch folgende Unterschiede:

Sicherheit gegen Brute-Force-Angriffe: Der bedeutendste und wichtigste Unterschied besteht darin, dass der SHA-Digest länger ist als der MD-Digest. Mit Brute-Force-Techniken ist die Schwierigkeit, eine Nachricht zu generieren, deren Digest einem bestimmten Nachrichten-Digest entspricht, eine Operation in der Größenordnung von MD und eine Operation in der Größenordnung von SHA-. Dadurch ist SHA besser gegen Brute-Force-Angriffe gewappnet.

Sicherheit gegen Kryptoanalyse: Aufgrund des Designs von MD ist es anfällig für Kryptoanalyse-Angriffe, während SHA- für solche Angriffe weniger anfällig zu sein scheint.

Geschwindigkeit: SHA – läuft langsamer als MD auf der gleichen Hardware.

Der vierte Typ.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中文网！