如何在Java中实现高性能的数据加密与解密算法

原创

省赚客开发者 2024-08-06 21:47:05 ©著作权

文章标签 java ci System 文章分类 Python 后端开发

©著作权归作者所有：来自51CTO博客作者省赚客开发者的原创作品，请联系作者获取转载授权，否则将追究法律责任

如何在Java中实现高性能的数据加密与解密算法

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！

一、引言

在现代应用中，数据安全至关重要。加密和解密算法能够保护敏感数据不被未授权访问。本文将介绍如何在Java中实现高性能的数据加密与解密算法，重点讲解对称加密算法AES和非对称加密算法RSA的实现与优化。

二、对称加密算法：AES

AES（Advanced Encryption Standard）是一种常见的对称加密算法，适用于需要快速处理大量数据的场景。

引入依赖

确保你的项目中引入了必要的依赖，例如Java自带的javax.crypto包即可满足需求。

实现AES加密与解密

在cn.juwatech.crypto包下创建一个AESUtil类：

package cn.juwatech.crypto;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESUtil {

    private static final String ALGORITHM = "AES";

    // 生成密钥
    public static SecretKey generateKey() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);
        keyGen.init(256); // 可以使用128, 192, 或 256 位
        return keyGen.generateKey();
    }

    // 加密
    public static String encrypt(String data, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    // 解密
    public static String decrypt(String encryptedData, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decodedBytes = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedBytes = cipher.doFinal(decodedBytes);
        return new String(decryptedBytes);
    }

    // 从字符串获取密钥
    public static SecretKey getKeyFromString(String keyString) {
        byte[] decodedKey = Base64.getDecoder().decode(keyString);
        return new SecretKeySpec(decodedKey, 0, decodedKey.length, ALGORITHM);
    }
}

测试AES加密与解密

在cn.juwatech包下创建一个测试类AESTest：

package cn.juwatech;

import cn.juwatech.crypto.AESUtil;

import javax.crypto.SecretKey;

public class AESTest {

    public static void main(String[] args) {
        try {
            // 生成密钥
            SecretKey secretKey = AESUtil.generateKey();
            String keyString = Base64.getEncoder().encodeToString(secretKey.getEncoded());
            System.out.println("Generated Key: " + keyString);

            // 加密数据
            String data = "Hello, World!";
            String encryptedData = AESUtil.encrypt(data, secretKey);
            System.out.println("Encrypted Data: " + encryptedData);

            // 解密数据
            SecretKey keyFromString = AESUtil.getKeyFromString(keyString);
            String decryptedData = AESUtil.decrypt(encryptedData, keyFromString);
            System.out.println("Decrypted Data: " + decryptedData);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

三、非对称加密算法：RSA

RSA（Rivest-Shamir-Adleman）是一种常见的非对称加密算法，适用于需要高安全性的数据传输。

实现RSA加密与解密

在cn.juwatech.crypto包下创建一个RSAUtil类：

package cn.juwatech.crypto;

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
import java.util.Base64;

public class RSAUtil {

    private static final String ALGORITHM = "RSA";

    // 生成密钥对
    public static KeyPair generateKeyPair() throws Exception {
        KeyPairGenerator keyGen = KeyPairGenerator.getInstance(ALGORITHM);
        keyGen.initialize(2048);
        return keyGen.generateKeyPair();
    }

    // 加密
    public static String encrypt(String data, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());
        return Base64.getEncoder().encodeToString(encryptedBytes);
    }

    // 解密
    public static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decodedBytes = Base64.getDecoder().decode(encryptedData);
        byte[] decryptedBytes = cipher.doFinal(decodedBytes);
        return new String(decryptedBytes);
    }

    // 从字符串获取公钥
    public static PublicKey getPublicKeyFromString(String keyString) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(keyString);
        X509EncodedKeySpec spec = new X509EncodedKeySpec(decodedKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePublic(spec);
    }

    // 从字符串获取私钥
    public static PrivateKey getPrivateKeyFromString(String keyString) throws Exception {
        byte[] decodedKey = Base64.getDecoder().decode(keyString);
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(decodedKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        return keyFactory.generatePrivate(spec);
    }
}

测试RSA加密与解密

在cn.juwatech包下创建一个测试类RSATest：

package cn.juwatech;

import cn.juwatech.crypto.RSAUtil;

import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Base64;

public class RSATest {

    public static void main(String[] args) {
        try {
            // 生成密钥对
            KeyPair keyPair = RSAUtil.generateKeyPair();
            String publicKeyString = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
            String privateKeyString = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
            System.out.println("Public Key: " + publicKeyString);
            System.out.println("Private Key: " + privateKeyString);

            // 加密数据
            String data = "Hello, RSA!";
            String encryptedData = RSAUtil.encrypt(data, keyPair.getPublic());
            System.out.println("Encrypted Data: " + encryptedData);

            // 解密数据
            PublicKey publicKey = RSAUtil.getPublicKeyFromString(publicKeyString);
            PrivateKey privateKey = RSAUtil.getPrivateKeyFromString(privateKeyString);
            String decryptedData = RSAUtil.decrypt(encryptedData, privateKey);
            System.out.println("Decrypted Data: " + decryptedData);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、性能优化