Java常用加密算法详解与示例代码_Java

1. 前言

在信息安全领域，加密算法是保护数据机密性、完整性和身份认证的核心手段。java 标准库及第三方框架（如 bouncycastle）提供了丰富的加解密实现，这里小编将结合 java 代码，详细介绍常用的几类加密算法，并给出可直接运行的测试示例，帮助小伙伴们快速上手。

2. 加密算法基础分类

2.1 哈希算法

特点：单向不可逆，固定长度输出
用途：数据完整性验证、密码存储
代表算法：md5、sha-1、sha-256、sha-512

2.2 对称加密算法

特点：加密解密使用相同密钥
优势：速度快，适合大数据量加密
代表算法：aes、des、3des、rc4

2.3 非对称加密算法

特点：公钥加密，私钥解密
优势：安全性高，解决密钥分发问题
代表算法：rsa、ecc、dsa

2.4 消息认证码（mac）

特点：带密钥的哈希函数
用途：验证消息完整性和来源
代表算法：hmac

3. 哈希算法

3.1 原理与特点

hash（摘要）：将任意长度的数据“压缩”成定长的输出，常用于数据完整性校验。
不可逆：无法从摘要反向推算原文；对抗碰撞攻击（不同输入产生相同输出）是设计目标之一。

3.2 java 示例

import java.security.messagedigest;
import java.security.nosuchalgorithmexception;

public class hashutils {

    public static string hash(string input, string algorithm) {
        try {
            messagedigest md = messagedigest.getinstance(algorithm);
            byte[] digest = md.digest(input.getbytes());
            // 转为十六进制
            stringbuilder sb = new stringbuilder();
            for (byte b : digest) {
                sb.append(string.format("%02x", b & 0xff));
            }
            return sb.tostring();
        } catch (nosuchalgorithmexception e) {
            throw new runtimeexception("unknown algorithm: " + algorithm, e);
        }
    }

    // 测试主函数
    public static void main(string[] args) {
        string text = "helloworld";
        system.out.println("md5:    " + hash(text, "md5"));
        system.out.println("sha-1:  " + hash(text, "sha-1"));
        system.out.println("sha-256:" + hash(text, "sha-256"));
    }
}

运行后，你将看到三种摘要值，验证不同算法的输出长度和差异。

4. 对称加密算法

对称加密使用同一个密钥进行加解密，速度快，适合大数据量场景。

由于 des 已较为过时，不推荐在新项目中使用，这里就不做des介绍了，下面主要讲解一下aes

2.1 aes（advanced encryption standard）

密钥长度：128/192/256 位
模式：ecb（电子密码本）、cbc（密码分组链接）等；cbc 更安全但需 iv

2.2 aes 示例

import javax.crypto.cipher;
import javax.crypto.keygenerator;
import javax.crypto.secretkey;
import javax.crypto.spec.ivparameterspec;
import java.util.base64;

public class aesutils {

    // 生成 aes 密钥
    public static secretkey genkey(int keysize) throws exception {
        keygenerator kg = keygenerator.getinstance("aes");
        kg.init(keysize);
        return kg.generatekey();
    }

    // 加密
    public static string encrypt(string plaintext, secretkey key, ivparameterspec iv) throws exception {
        cipher cipher = cipher.getinstance("aes/cbc/pkcs5padding");
        cipher.init(cipher.encrypt_mode, key, iv);
        byte[] encrypted = cipher.dofinal(plaintext.getbytes());
        return base64.getencoder().encodetostring(encrypted);
    }

    // 解密
    public static string decrypt(string ciphertext, secretkey key, ivparameterspec iv) throws exception {
        cipher cipher = cipher.getinstance("aes/cbc/pkcs5padding");
        cipher.init(cipher.decrypt_mode, key, iv);
        byte[] decoded = base64.getdecoder().decode(ciphertext);
        byte[] decrypted = cipher.dofinal(decoded);
        return new string(decrypted);
    }

    public static void main(string[] args) throws exception {
        string text = "secretmessage";
        secretkey key = genkey(128);
        // 随机 iv，也可使用固定 iv（不推荐）
        byte[] ivbytes = new byte[16];
        system.arraycopy("randominitvector".getbytes(), 0, ivbytes, 0, 16);
        ivparameterspec iv = new ivparameterspec(ivbytes);

        string ciphertext = encrypt(text, key, iv);
        string plaintext = decrypt(ciphertext, key, iv);

        system.out.println("原文: " + text);
        system.out.println("加密: " + ciphertext);
        system.out.println("解密: " + plaintext);
    }
}

5. 非对称加密算法

5.1 rsa算法

算法特点：

基于大数分解难题
密钥长度：1024-4096位
用途：数字签名、密钥交换

import javax.crypto.cipher;
import java.nio.charset.standardcharsets;
import java.security.*;
import java.security.spec.pkcs8encodedkeyspec;
import java.security.spec.x509encodedkeyspec;
import java.util.base64;

public class rsaexample {
    public static void main(string[] args) throws exception {
        string plaintext = "java非对称加密算法";
        
        // 生成密钥对
        keypair keypair = generatersakeypair();
        publickey publickey = keypair.getpublic();
        privatekey privatekey = keypair.getprivate();
        
        // 公钥加密
        byte[] ciphertext = encryptrsa(plaintext, publickey);
        system.out.println("rsa加密结果: " + base64.getencoder().encodetostring(ciphertext));
        
        // 私钥解密
        string decryptedtext = decryptrsa(ciphertext, privatekey);
        system.out.println("rsa解密结果: " + decryptedtext);
        
        // 数字签名示例
        byte[] signature = signdata(plaintext, privatekey);
        boolean isvalid = verifysignature(plaintext, signature, publickey);
        system.out.println("签名验证结果: " + isvalid);
    }

    public static keypair generatersakeypair() throws exception {
        keypairgenerator keypairgenerator = keypairgenerator.getinstance("rsa");
        keypairgenerator.initialize(2048); // 密钥长度
        return keypairgenerator.generatekeypair();
    }

    public static byte[] encryptrsa(string plaintext, publickey publickey) throws exception {
        cipher cipher = cipher.getinstance("rsa/ecb/oaepwithsha-256andmgf1padding");
        cipher.init(cipher.encrypt_mode, publickey);
        return cipher.dofinal(plaintext.getbytes(standardcharsets.utf_8));
    }

    public static string decryptrsa(byte[] ciphertext, privatekey privatekey) throws exception {
        cipher cipher = cipher.getinstance("rsa/ecb/oaepwithsha-256andmgf1padding");
        cipher.init(cipher.decrypt_mode, privatekey);
        byte[] decryptedbytes = cipher.dofinal(ciphertext);
        return new string(decryptedbytes, standardcharsets.utf_8);
    }

    public static byte[] signdata(string data, privatekey privatekey) throws exception {
        signature signature = signature.getinstance("sha256withrsa");
        signature.initsign(privatekey);
        signature.update(data.getbytes(standardcharsets.utf_8));
        return signature.sign();
    }

    public static boolean verifysignature(string data, byte[] signaturebytes, publickey publickey) throws exception {
        signature signature = signature.getinstance("sha256withrsa");
        signature.initverify(publickey);
        signature.update(data.getbytes(standardcharsets.utf_8));
        return signature.verify(signaturebytes);
    }
}

5.2 ecc（椭圆曲线加密）

算法特点：

同等安全强度下密钥更短
计算效率高
适合移动设备

import java.nio.charset.standardcharsets;
import java.security.*;
import java.security.spec.pkcs8encodedkeyspec;
import java.security.spec.x509encodedkeyspec;
import java.util.base64;

public class eccexample {
    public static void main(string[] args) throws exception {
        string plaintext = "java椭圆曲线加密";
        
        // 生成密钥对
        keypair keypair = generateecckeypair();
        publickey publickey = keypair.getpublic();
        privatekey privatekey = keypair.getprivate();
        
        // 密钥序列化/反序列化演示
        string pubkeystr = base64.getencoder().encodetostring(publickey.getencoded());
        string prikeystr = base64.getencoder().encodetostring(privatekey.getencoded());
        
        // 从字符串恢复密钥
        publickey restoredpubkey = restoreeccpublickey(pubkeystr);
        privatekey restoredprikey = restoreeccprivatekey(prikeystr);
        
        // 数字签名
        byte[] signature = signdataecc(plaintext, restoredprikey);
        boolean isvalid = verifysignatureecc(plaintext, signature, restoredpubkey);
        system.out.println("ecc签名验证结果: " + isvalid);
    }

    public static keypair generateecckeypair() throws exception {
        keypairgenerator keypairgenerator = keypairgenerator.getinstance("ec");
        keypairgenerator.initialize(256); // 密钥长度
        return keypairgenerator.generatekeypair();
    }

    public static publickey restoreeccpublickey(string keystr) throws exception {
        byte[] keybytes = base64.getdecoder().decode(keystr);
        x509encodedkeyspec keyspec = new x509encodedkeyspec(keybytes);
        keyfactory keyfactory = keyfactory.getinstance("ec");
        return keyfactory.generatepublic(keyspec);
    }

    public static privatekey restoreeccprivatekey(string keystr) throws exception {
        byte[] keybytes = base64.getdecoder().decode(keystr);
        pkcs8encodedkeyspec keyspec = new pkcs8encodedkeyspec(keybytes);
        keyfactory keyfactory = keyfactory.getinstance("ec");
        return keyfactory.generateprivate(keyspec);
    }

    public static byte[] signdataecc(string data, privatekey privatekey) throws exception {
        signature signature = signature.getinstance("sha256withecdsa");
        signature.initsign(privatekey);
        signature.update(data.getbytes(standardcharsets.utf_8));
        return signature.sign();
    }

    public static boolean verifysignatureecc(string data, byte[] signaturebytes, publickey publickey) throws exception {
        signature signature = signature.getinstance("sha256withecdsa");
        signature.initverify(publickey);
        signature.update(data.getbytes(standardcharsets.utf_8));
        return signature.verify(signaturebytes);
    }
}

6. 消息认证码（hmac）

hmac 用于验证数据完整性及认证，结合了 hash 与密钥。

算法特点：

输入：密钥 + 消息 → 通过 hash 计算，输出固定长度摘要。
常见算法：hmacmd5、hmacsha1、hmacsha256

import javax.crypto.mac;
import javax.crypto.spec.secretkeyspec;
import java.nio.charset.standardcharsets;
import java.security.invalidkeyexception;
import java.security.nosuchalgorithmexception;
import java.util.base64;

public class hmacexample {
    public static void main(string[] args) throws exception {
        string message = "重要业务数据";
        string secretkey = "mysecretkey123";
        
        // 计算hmac
        string hmac = calculatehmac(message, secretkey);
        system.out.println("hmac-sha256: " + hmac);
        
        // 验证消息完整性
        string receivedmessage = "重要业务数据";
        string receivedhmac = calculatehmac(receivedmessage, secretkey);
        system.out.println("hmac验证结果: " + hmac.equals(receivedhmac));
    }

    public static string calculatehmac(string data, string key) 
            throws nosuchalgorithmexception, invalidkeyexception {
        mac sha256hmac = mac.getinstance("hmacsha256");
        secretkeyspec secretkey = new secretkeyspec(
            key.getbytes(standardcharsets.utf_8), 
            "hmacsha256"
        );
        sha256hmac.init(secretkey);
        byte[] hmacbytes = sha256hmac.dofinal(data.getbytes(standardcharsets.utf_8));
        return base64.getencoder().encodetostring(hmacbytes);
    }
}