加解密算法是计算机安全领域中的重要组成部分，它们可以用于保证数据的安全性和隐私保护。

应用场景

加解密算法在互联网应用场景中有着广泛的应用，以下是几个常见的应用场景：

HTTPS通信

HTTPS（Hypertext Transfer Protocol Secure）是一种安全的HTTP协议，它使用SSL/TLS加密协议来保护数据传输过程中的隐私和安全。HTTPS通信使用非对称加密算法来建立安全通信通道，然后使用对称加密算法来加密数据。 HTTPS通信可以保证网站的安全性和用户的隐私保护。

数据库加密

数据库中存储着大量的敏感数据，为了保护数据的安全性，可以使用加密算法来对数据进行加密。

文件加密

在互联网应用中，文件传输时需要保证文件的机密性和完整性，可以使用加密算法对文件进行加密和签名。

用户身份验证

在互联网应用中，用户身份验证是一个重要的安全问题，可以使用加密算法对用户密码进行加密存储，防止密码泄露和破解。

数字签名

数字签名是一种用于验证文档或数据的完整性和真实性的技术。数字签名使用非对称加密算法对文档或数据进行签名，然后使用公钥来验证签名的正确性。数字签名可以保证数据的安全性和真实性。 常见的数字签名算法包括RSA、DSA等。

算法分类

对称加密算法

对称加密算法使用相同的密钥对数据进行加密和解密。 对称加密算法的优点是加解密速度快，但是密钥管理比较困难。

DES

DES（Data Encryption Standard）算法是一种对称加密算法，是1970年代中期由IBM研发的，是最早广泛应用的加密算法之一。DES算法使用64位密钥对64位数据块进行加密和解密，它的加密过程包括以下步骤：

1. 初始置换（Initial Permutation，IP）：将输入的64位数据块按照指定的规则进行置换，得到一个新的64位数据块。
2. 16轮加密（Round）：将初始置换得到的64位数据块分为左右两部分，每轮加密使用右半部分作为输入，使用48位密钥对右半部分进行扩展和置换，然后与左半部分进行异或操作，得到一个新的右半部分。然后将左右两部分交换，进入下一轮加密。
3. 末置换（Final Permutation，FP）：将经过16轮加密得到的64位数据块按照指定的规则进行置换，得到最终的加密结果。 DES算法使用密钥长度为64位，但实际上只有56位被用于加密，剩下的8位用于奇偶校验。 由于DES使用固定长度的密钥，密钥管理比较困难，因此后来出现了3DES和AES等更为安全的加密算法。 尽管DES已经不再被广泛使用，但它仍然具有历史意义和教学价值。同时，DES也为后来的加密算法提供了重要的参考和启示。

使用举例

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class DESExample {
    private static final String ALGORITHM = "DES";
    private static final String KEY = "12345678"; // 密钥，长度必须为8位

    public static byte[] encrypt(byte[] input) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        return cipher.doFinal(input);
    }

    public static byte[] decrypt(byte[] input) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        return cipher.doFinal(input);
    }

    public static void main(String[] args) throws Exception {
        String plainText = "Hello, world!";
        byte[] encrypted = encrypt(plainText.getBytes());
        System.out.println("Encrypted text: " + new String(encrypted));
        byte[] decrypted = decrypt(encrypted);
        System.out.println("Decrypted text: " + new String(decrypted));
    }
}

3DES

3DES（Triple Data Encryption Standard）算法是一种对称加密算法，也称为DESede，是DES算法的加强版。3DES算法使用3个56位的密钥对数据进行加密和解密，它的加密过程包括以下步骤：

1. 第一次DES加密：使用第一个密钥对数据块进行加密。
2. 第二次DES解密：使用第二个密钥对第一次加密得到的结果进行解密。
3. 第三次DES加密：使用第三个密钥对第二次解密得到的结果进行加密。 3DES算法的加密过程相当于对数据进行了两次加密和一次解密，因此安全性更高。同时，3DES算法也可以使用两个密钥，即双重DES（2DES）算法，但这种算法已经不再被推荐使用。 3DES算法已经成为广泛使用的加密算法之一，它的安全性比DES算法更高，但速度比DES算法慢。因此，在实际应用中，需要根据实际需求选择合适的加密算法。 同时，3DES算法已经逐渐被更安全和更快速的加密算法所取代，如AES算法。

使用举例

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

public class TripleDESExample {
    private static final String ALGORITHM = "DESede";
    private static final String KEY = "123456789012345678901234"; // 密钥，长度必须为24位

    public static byte[] encrypt(byte[] input) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        return cipher.doFinal(input);
    }

    public static byte[] decrypt(byte[] input) throws Exception {
        SecretKeySpec keySpec = new SecretKeySpec(KEY.getBytes(), ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        return cipher.doFinal(input);
    }

    public static void main(String[] args) throws Exception {
        String plainText = "Hello, world!";
        byte[] encrypted = encrypt(plainText.getBytes());
        System.out.println("Encrypted text: " + new String(encrypted));
        byte[] decrypted = decrypt(encrypted);
        System.out.println("Decrypted text: " + new String(decrypted));
    }
}

AES

AES（Advanced Encryption Standard）算法是一种对称加密算法，是目前应用最为广泛的加密算法之一。AES算法使用128、192或256位密钥对数据进行加密和解密，它的加密过程包括以下步骤：

1. 初始轮（Initial Round）：将输入的数据块与密钥进行异或操作。
2. 多轮加密（Main Rounds）：AES算法使用多轮加密，每轮加密包括以下四个步骤： 字节代替（SubBytes）：使用S盒对数据块中的每个字节进行替换。 行移位（ShiftRows）：对数据块中的每行进行循环位移。 列混淆（MixColumns）：对数据块中的每列进行混淆。 轮密钥加（AddRoundKey）：将数据块与轮密钥进行异或操作。
3. 最终轮（Final Round）：在最后一轮加密中，省略列混淆步骤。 AES算法比DES算法和3DES算法更加安全和高效，因此在实际应用中得到了广泛的应用。AES算法支持多种密钥长度，其中128位密钥是最为常用的。同时，AES算法的安全性和性能也受到密钥长度的影响，应该根据实际需求选择合适的密钥长度。 需要注意的是，AES算法的密钥长度必须为16、24或32，分别对应128、192和256位密钥。 在实际应用中，密钥的生成和管理也是非常重要的一环，应该采取安全的方式来生成和管理密钥。

AES-GCM

AES-GCM（高级加密标准-盖洛瓦/计数器模式）是一种广泛使用的加密算法，它为数据提供了机密性和完整性保护。它将AES加密算法与盖洛瓦/计数器模式（GCM）结合在一起。

AES-GCM使用一个12字节的随机数作为初始化向量（IV）和一个128位的密钥来加密和解密数据。它使用GCM模式的加密过程来生成一个身份验证标签（authentication tag），并将其附加到密文中。身份验证标签是一个128位的值，用于验证加密的数据在传输过程中是否被篡改。

AES-GCM的优点包括高效性，可并行性和安全性。它可以在硬件和软件上高效地实现，并且能够处理大量数据。此外，它还提供了保密性和完整性保护，以保护数据不受未经授权的访问和篡改。

总的来说，AES-GCM是一种安全可靠的加密算法，适用于保护敏感数据的传输和存储。

使用验证

import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;

public class AESGCMExample {

    private static final int GCM_TAG_LENGTH = 16;
    private static final int GCM_IV_LENGTH = 12;
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/GCM/NoPadding";

    public static void main(String[] args) throws Exception {
        // Generate a random 128-bit AES key
        byte[] key = new byte[16];
        SecureRandom secureRandom = new SecureRandom();
        secureRandom.nextBytes(key);

        // Generate a random 96-bit initialization vector (IV)
        byte[] iv = new byte[GCM_IV_LENGTH];
        secureRandom.nextBytes(iv);

        // Encrypt the plaintext
        String plaintext = "Hello, world!";
        byte[] ciphertext = encrypt(plaintext.getBytes(), key, iv);

        // Decrypt the ciphertext
        byte[] decrypted = decrypt(ciphertext, key, iv);
        String decryptedText = new String(decrypted);

        System.out.println("Plaintext: " + plaintext);
        System.out.println("Ciphertext: " + new String(ciphertext));
        System.out.println("Decrypted text: " + decryptedText);
    }

    public static byte[] encrypt(byte[] plaintext, byte[] key, byte[] iv) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmSpec);
        byte[] encrypted = cipher.doFinal(plaintext);
        byte[] ivAndCiphertext = new byte[iv.length + encrypted.length];
        System.arraycopy(iv, 0, ivAndCiphertext, 0, iv.length);
        System.arraycopy(encrypted, 0, ivAndCiphertext, iv.length, encrypted.length);
        return ivAndCiphertext;
    }

    public static byte[] decrypt(byte[] ivAndCiphertext, byte[] key, byte[] iv) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        SecretKeySpec keySpec = new SecretKeySpec(key, ALGORITHM);
        GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
        cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmSpec);
        byte[] ciphertext = new byte[ivAndCiphertext.length - iv.length];
        System.arraycopy(ivAndCiphertext, iv.length, ciphertext, 0, ciphertext.length);
        byte[] decrypted = cipher.doFinal(ciphertext);
        return decrypted;
    }
}

其他算法

RC4 IDEA Blowfish Camellia 需要注意的是，对称加密算法的安全性和性能都受到密钥长度、加密轮数等因素的影响，应该根据实际需求选择合适的加密算法。 同时，对称加密算法的密钥管理也是非常重要的一环，应该采取安全的方式来生成、传输和管理密钥。

非对称加密

非对称加密算法使用一对公钥和私钥对文件进行加密和解密。 它需要两个密钥，一个称为 公开密钥 (public key)，即 公钥，另一个称为 私有密钥 (private key)，即 私钥。

1.如果使用公钥对数据进行加密，只有用对应的私钥才能进行解密。 2.如果使用私钥对数据进行加密，只有用对应的公钥才能进行解密。

RSA

RSA算法是一种非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年发明。RSA算法的安全性基于大数分解的困难性，它使用两个密钥进行加密和解密，分别称为公钥和私钥。 RSA算法的加密过程如下：

1. 选择两个大质数p和q，并计算它们的乘积n=p*q。
2. 计算欧拉函数φ(n)=(p-1)*(q-1)。
3. 选择一个整数e（1<e<φ(n)），使得e与φ(n)互质。
4. 计算e的模φ(n)下的乘法逆元d，即满足e*d ≡ 1 (mod φ(n))的最小正整数d。
5. 公钥为(n, e)，私钥为(n, d)。
6. 加密：将明文转换为整数M，然后计算密文C=M^e (mod n)。

RSA算法的解密过程如下：

1. 解密：将密文C计算出明文M=C^d (mod n)。 RSA算法的安全性基于大数分解的困难性，即将一个大数n分解成两个大质数p和q的乘积的难度。因此，RSA算法的安全性取决于p和q的长度，一般要求它们的长度至少为2048位。

RSA 加密算法是目前最有影响力的 公钥加密算法，并且被普遍认为是目前 最优秀的公钥方案 之一。 RSA 是第一个能同时用于 加密 和 数字签名 的算法，它能够 抵抗 到目前为止已知的 所有密码攻击，已被 ISO 推荐为公钥数据加密标准。

生成公私钥

在Linux、Mac OS X和Windows（使用Git Bash或Cygwin等模拟Linux环境的工具）操作系统中，可以使用ssh-keygen命令生成RSA、DSA、ECDSA或ED25519密钥对。

以下是使用ssh-keygen命令生成2048位RSA密钥对的步骤：

打开终端或命令行窗口：在Linux、Mac OS X和Windows中，可以使用终端或命令行窗口来执行ssh-keygen命令。

输入ssh-keygen命令：在终端或命令行窗口中，输入以下命令，生成2048位RSA密钥对。其中，-t参数指定密钥类型为RSA，-b参数指定密钥长度为2048位，-C参数指定注释信息。

ssh-keygen -t rsa -b 2048 -C "your_email@example.com"

选择密钥保存路径和文件名：ssh-keygen命令将提示输入密钥保存路径和文件名，默认路径为用户主目录下的.ssh目录，文件名为id_rsa和id_rsa.pub。如果需要自定义路径和文件名，可以输入相应的信息。 输入密钥保护密码（可选）：ssh-keygen命令将提示输入密钥保护密码。如果需要对私钥进行加密保护，可以输入密码；否则，可以直接按下回车键。 查看密钥：ssh-keygen命令将生成两个文件：私钥文件（默认为id_rsa）和公钥文件（默认为id_rsa.pub）。可以使用cat命令或编辑器来查看公钥文件的内容，将公钥文件的内容复制到需要使用公钥的地方即可。 需要注意的是，生成RSA密钥对时，应该选择合适的密钥长度，并采取随机化的方式生成密钥，以提高密钥的安全性。同时，生成的密钥也需要进行适当的保护和管理，以避免密钥泄露和损坏。

常用方式

数字证书

数字证书是用于身份验证和安全通信的一种数字凭证。数字证书中包含了一个实体的公钥和相关的身份信息，由数字证书颁发机构（CA）进行签名。RSA算法常用于生成数字证书中的公钥和私钥，以及进行数字签名和验证。通过数字证书，可以实现安全的网络通信、电子商务等应用。

数字签名

数字签名是一种用于验证电子文档完整性和身份认证的技术。数字签名通常使用RSA算法生成公钥和私钥，然后使用私钥对文档进行签名，将签名和文档一起传输给接收方。接收方可以使用公钥验证签名的完整性和真实性，从而确保文档未被篡改，并且签名者的身份可信。

加密通信

RSA算法也可以用于保护网络通信中的数据隐私。在加密通信中，发送方使用接收方的公钥对数据进行加密，接收方使用自己的私钥对数据进行解密。由于只有接收方才知道自己的私钥，因此只有接收方能够解密数据，保证了数据的机密性。

SSH登录

SSH是一种安全的远程登录协议，常用于远程管理Linux服务器。在SSH登录中，服务器通常使用RSA算法生成公钥和私钥对，客户端使用公钥对密码进行加密，然后将加密后的密码发送给服务器进行验证。由于只有服务器拥有私钥，因此只有服务器能够解密密码，从而确保了登录的安全性。

使用举例

import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import javax.crypto.Cipher;

public class RSAExample {
    private static final String ALGORITHM = "RSA";
    private static final String TRANSFORMATION = "RSA/ECB/PKCS1Padding";
    private static final int KEY_SIZE = 2048;
    private static final String CHARSET = "UTF-8";

    public static void main(String[] args) throws Exception {
        String plainText = "Hello, RSA!";
        System.out.println("原文：" + plainText);

        // 生成RSA公钥和私钥
        KeyPair keyPair = generateKeyPair(KEY_SIZE);

        // 使用公钥加密
        byte[] encryptedBytes = encrypt(plainText.getBytes(CHARSET), keyPair.getPublic());
        System.out.println("加密后：" + new String(encryptedBytes, CHARSET));

        // 使用私钥解密
        byte[] decryptedBytes = decrypt(encryptedBytes, keyPair.getPrivate());
        System.out.println("解密后：" + new String(decryptedBytes, CHARSET));
    }

    /**
     * 生成RSA公钥和私钥
     */
    public static KeyPair generateKeyPair(int keySize) throws NoSuchAlgorithmException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(keySize, new SecureRandom());
        return keyPairGenerator.generateKeyPair();
    }

    /**
     * 使用公钥加密
     */
    public static byte[] encrypt(byte[] plainBytes, Key publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(plainBytes);
    }

    /**
     * 使用私钥解密
     */
    public static byte[] decrypt(byte[] encryptedBytes, Key privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(encryptedBytes);
    }
}

DSA

DSA（Digital Signature Algorithm，数字签名算法）是一种公钥密码学算法，用于生成和验证数字签名。 DSA算法是美国国家标准技术研究所（NIST）于1994年发布的，主要用于数字证书、电子邮件、电子票据等领域。 DSA算法基于离散对数问题，与RSA算法不同。DSA算法的安全性基于离散对数问题的困难性，即在给定的椭圆曲线和点的情况下，找到满足公式 Q=kPQ = kPQ=kP 的kkk值。DSA算法的主要优点是在密钥长度相同的情况下，其签名和验证速度比RSA算法更快。 DSA算法的核心是一个椭圆曲线，该曲线由一个有限域上的椭圆方程定义。DSA算法中使用的椭圆曲线可以是标准曲线，也可以是自定义曲线。DSA算法使用的密钥包括公钥和私钥，其中私钥用于签名，公钥用于验证签名。 DSA算法的签名过程如下：

1. 选择一个椭圆曲线和一个基点PPP，并选取一个随机数kkk。
2. 计算kPkPkP的坐标(x1,y1)(x_1,y_1)(x1​,y1​)，并将x1x_1x1​的哈希值作为随机数rrr。
3. 计算s=k−1(H(m)+xr) mod qs=k^{-1}(H(m)+xr)\bmod qs=k−1(H(m)+xr)modq，其中qqq是一个素数，H(m)H(m)H(m)是消息mmm的哈希值。
4. 签名为(r,s)(r,s)(r,s)。

DSA算法的验证过程如下：

1. 使用签名方提供的公钥，计算w=s−1 mod qw=s^{-1}\bmod qw=s−1modq。
2. 计算u1=H(m)w mod qu_1=H(m)w\bmod qu1​=H(m)wmodq和u2=rw mod qu_2=rw\bmod qu2​=rwmodq。
3. 计算V=u1P+u2QV=u_1P+u_2QV=u1​P+u2​Q，其中QQQ是公钥。
4. 如果VVV的xxx坐标等于rrr，则验证通过；否则，验证失败。

需要注意的是，为了确保DSA算法的安全性，密钥的长度应足够长。标准的DSA密钥长度为1024位或2048位，但随着计算机技术的发展，密钥长度可能需要更长才能保证安全。同时，DSA算法的实现也需要考虑到各种攻击和漏洞，如侧信道攻击、摩尔斯漏洞等。 因此，在实际应用中，应该选择合适的密钥长度和实现方式，以确保数据的安全性。

ECC

ECC（Elliptic Curve Cryptography，椭圆曲线密码学）是一种基于椭圆曲线数学理论的公钥加密算法和数字签名算法。与RSA和DSA等传统的公钥加密算法和数字签名算法相比，ECC算法具有更高的安全性、更小的密钥尺寸和更高的计算效率。

ECC算法的安全性基于椭圆曲线上的离散对数问题。椭圆曲线是一个平面上的曲线，其数学性质具有离散对数问题的复杂性质。ECC算法利用这种数学性质，将椭圆曲线上的点作为公钥，利用私钥和公钥之间的关系来实现加密和数字签名。

ECC算法的密钥尺寸比传统的公钥加密算法和数字签名算法小得多，通常只需要256位或更少的密钥长度就能提供相同的安全性。这使得ECC算法在资源受限的设备上得到广泛应用，如智能卡、移动设备和物联网设备等。

ECC算法在实际应用中得到了广泛的应用，如SSL/TLS协议、数字证书、移动支付、智能卡等领域。需要注意的是，ECC算法也可能存在安全漏洞和攻击，因此在实际应用中应该选择合适的椭圆曲线参数和密钥长度，并采取适当的保护措施，如密钥管理和安全协议设计等。

使用举例

import java.security.*;
import java.security.spec.ECGenParameterSpec;
import javax.crypto.KeyAgreement;

public class ECCExample {
    public static void main(String[] args) throws Exception {
        // 生成ECC密钥对
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
        ECGenParameterSpec ecps = new ECGenParameterSpec("secp256r1");
        kpg.initialize(ecps);
        KeyPair kp = kpg.generateKeyPair();
        PublicKey pubKey = kp.getPublic();
        PrivateKey priKey = kp.getPrivate();

        // 将公钥和私钥导出到字节数组
        byte[] pubKeyBytes = pubKey.getEncoded();
        byte[] priKeyBytes = priKey.getEncoded();

        // 使用ECDH协议实现密钥协商
        KeyAgreement ka = KeyAgreement.getInstance("ECDH");
        ka.init(priKey);
        ka.doPhase(pubKey, true);
        byte[] sharedSecret = ka.generateSecret();

        System.out.println("ECC公钥：" + bytesToHex(pubKeyBytes));
        System.out.println("ECC私钥：" + bytesToHex(priKeyBytes));
        System.out.println("ECDH共享密钥：" + bytesToHex(sharedSecret));
    }

    /**
     * 将字节数组转换为16进制字符串
     */
    public static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b & 0xff));
        }
        return sb.toString();
    }
}

哈希算法

哈希算法是一种常用的密码学算法，也称为散列算法或摘要算法。哈希算法将任意长度的输入数据（也称为消息）转换为固定长度的输出数据，通常称为哈希值或摘要。哈希值的长度通常是固定的，例如MD5哈希值为128位，SHA-256哈希值为256位。 哈希算法的主要用途包括：

1. 数据完整性检查：哈希算法可以用于验证数据的完整性，例如下载文件时可以计算文件的哈希值，并与发布者提供的哈希值进行比较，以确保文件未被篡改。
2. 数字签名：哈希算法可以用于生成数字签名，例如使用私钥对消息的哈希值进行加密，生成数字签名，然后使用公钥进行验证，以确保消息的真实性和完整性。
3. 安全存储密码：哈希算法可以用于安全存储密码，例如将用户密码的哈希值存储在数据库中，而不是明文密码。当用户登录时，系统将用户输入的密码计算哈希值，并与存储的哈希值进行比较，以验证密码的正确性。

MD5

MD5算法是一种常用的哈希算法，用于将任意长度的消息转换为128位的哈希值。MD5算法由美国密码学家Ronald Rivest于1991年提出，是MD4算法的改进版。 MD5算法的优点是速度快、计算简单，适合于大量数据的哈希计算。但是，由于其安全性存在漏洞，如碰撞攻击和预映射攻击等，已经不推荐使用。

SHA-3

SHA-3（Secure Hash Algorithm 3）是一种密码学哈希函数，由美国国家标准技术研究所（NIST）于2015年发布，是SHA算法家族的最新成员。SHA-3算法是作为SHA-2算法的替代品而发布的，旨在提供更高的安全性和更好的性能。 SHA-3算法的输入可以是任意长度的消息，输出固定长度的哈希值，常用的SHA-3哈希值长度包括224位、256位、384位和512位。SHA-3算法的设计目标是在硬件和软件实现中都能提供高效的性能和高度的安全性，同时保持较小的代码和数据存储需求。 SHA-3算法的实现方式与其他哈希算法类似，通常分为初始化、消息迭代和输出三个步骤。 SHA-3算法的安全性基于其内部的置换和扩散函数，这些函数具有良好的随机性和不可逆性，保证了哈希值的唯一性和不可预测性。

使用举例

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class SHA3Example {
    public static void main(String[] args) throws NoSuchAlgorithmException {
        String plainText = "Hello, SHA-3!";
        System.out.println("原文：" + plainText);

        // 计算SHA-3哈希值
        String sha3Digest = sha3(plainText.getBytes(), 256);
        System.out.println("SHA-3哈希值：" + sha3Digest);
    }

    /**
     * 计算SHA-3哈希值
     */
    public static String sha3(byte[] input, int length) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA3-" + length);
        byte[] digest = md.digest(input);
        StringBuilder sb = new StringBuilder();
        for (byte b : digest) {
            sb.append(String.format("%02x", b & 0xff));
        }
        return sb.toString();
    }
}

SHA-256

SHA-256（Secure Hash Algorithm 256）是一种密码学哈希函数，属于SHA-2算法家族。SHA-256算法由美国国家标准技术研究所（NIST）于2001年发布，是SHA-1算法的改进版本，提供了更高的安全性和更好的性能。 输出固定256位

对称加密算法与非对称加密算法的结合

对称加密算法和非对称加密算法可以结合使用，称为混合加密算法。混合加密算法通常使用非对称加密算法来传输对称加密算法所使用的密钥，以保证密钥传输的安全性。 常见的混合加密算法包括RSA+AES、ECC+AES等。

对称加密算法与哈希算法的结合

对称加密算法和哈希算法可以结合使用，称为消息认证码（Message Authentication Code，MAC）。MAC可以用于数据完整性验证和数字签名，常见的MAC算法包括HMAC等。

HMAC

HMAC（Hash-based Message Authentication Code，基于哈希函数的消息认证码）是一种基于哈希函数的消息认证算法。HMAC算法由H.Krawczyk、M.Bellare和R.Canetti于1997年提出，是一种针对哈希函数的密钥相关性校验算法。 HMAC算法的安全性基于哈希函数的抗碰撞和不可逆性特性，以及密钥的保密性。HMAC算法可以用于验证消息的完整性和真实性，防止消息被篡改和伪造。HMAC算法的计算过程如下：

1. 选择一个合适的哈希函数，如SHA-256、SHA-512等。
2. 选择一个密钥，并将其与消息进行组合。
3. 对组合后的消息计算哈希值。
4. 将计算得到的哈希值与密钥进行再次组合，并计算哈希值。
5. 最终的哈希值即为HMAC值。

HMAC算法具有以下优点：

1. 安全性高：HMAC算法利用哈希函数的抗碰撞和不可逆性特性，以及密钥的保密性，提供了高强度的安全性保障。
2. 灵活性好：HMAC算法可以使用不同的哈希函数和密钥长度，以及不同的消息和密钥组合方式，提供了灵活的应用场景。
3. 计算效率高：HMAC算法的计算速度较快，适用于实时性要求较高的应用场景。

使用举例

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public class HMACExample {
    public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException {
        String message = "Hello, HMAC!";
        String key = "secret";

        // 计算HMAC-SHA256值
        String hmacSha256 = hmacSha256(message.getBytes(), key.getBytes());

        System.out.println("原文：" + message);
        System.out.println("密钥：" + key);
        System.out.println("HMAC-SHA256值：" + hmacSha256);
    }

    /**
     * 计算HMAC-SHA256值
     */
    public static String hmacSha256(byte[] message, byte[] key) throws NoSuchAlgorithmException, InvalidKeyException {
        Mac mac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKeySpec = new SecretKeySpec(key, "HmacSHA256");
        mac.init(secretKeySpec);
        byte[] hmac = mac.doFinal(message);
        StringBuilder sb = new StringBuilder();
        for (byte b : hmac) {
            sb.append(String.format("%02x", b & 0xff));
        }
        return sb.toString();
    }
}

总结

哈希算法推荐使用SHA-3 SHA-256 非对称加密算法推荐使用RSA 对接加密算法不推荐使用