Bagaimana untuk melaksanakan algoritma penyulitan RSA menggunakan java

Cara melaksanakan algoritma penyulitan RSA menggunakan Java

RSA (Rivest-Shamir-Adleman) ialah algoritma penyulitan asimetri, yang kini merupakan salah satu daripada algoritma penyulitan yang paling biasa digunakan. Artikel ini akan memperkenalkan cara menggunakan bahasa Java untuk melaksanakan algoritma penyulitan RSA dan memberikan contoh kod khusus.

1. Jana pasangan kunci

Pertama, kita perlu menjana sepasang kunci RSA, yang terdiri daripada kunci awam dan kunci persendirian. Kunci awam boleh digunakan untuk menyulitkan data dan kunci peribadi boleh digunakan untuk menyahsulit data. Berikut ialah contoh kod untuk menjana pasangan kunci RSA:

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;

public class RSAKeyGenerator {
    public static void main(String[] args) {
        try {
            // 创建RSA密钥对生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            // 初始化密钥长度为2048位
            keyPairGenerator.initialize(2048);
            // 生成密钥对
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            // 获取公钥
            String publicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded());
            System.out.println("公钥：" + publicKey);
            // 获取私钥
            String privateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded());
            System.out.println("私钥：" + privateKey);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

Kod di atas menggunakan kelas KeyPairGenerator untuk menjana pasangan kunci RSA dan menukar kunci awam dan peribadi melalui Base64< /code> class Tukar kepada rentetan berkod Base64. <code>KeyPairGenerator类来生成RSA密钥对，并通过Base64类将公钥和私钥转换成Base64编码的字符串。

2. 使用公钥加密数据

接下来，我们将使用公钥对数据进行加密。以下是使用RSA公钥加密数据的代码示例：

import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;

public class RSAEncryptor {
    public static void main(String[] args) {
        try {
            // 原始数据
            String data = "Hello, world!";
            // 公钥字符串（Base64编码）
            String publicKeyString = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALloSaH+P1Z1Q1A/qs3gejbddklEiROWf2EadwZ68GBgzHk491icoP5x24SBOweiYA+xSqNxxFxSKuWpMu922hMCAwEAAQ==";

            // 将公钥字符串转换为公钥对象
            byte[] publicKeyBytes = Base64.getDecoder().decode(publicKeyString);
            PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(publicKeyBytes));

            // 创建RSA密码器
            Cipher cipher = Cipher.getInstance("RSA");
            // 使用公钥进行加密
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            byte[] encryptedData = cipher.doFinal(data.getBytes("UTF-8"));

            // 输出加密后的数据（Base64编码）
            String encryptedDataString = Base64.getEncoder().encodeToString(encryptedData);
            System.out.println("加密后的数据：" + encryptedDataString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上述代码使用Cipher类进行数据加密。首先，将公钥字符串转换为公钥对象。然后，创建RSA密码器并使用公钥进行初始化。最后，调用doFinal方法对数据进行加密，并将加密后的数据转换为Base64编码的字符串输出。

3. 使用私钥解密数据

最后，我们使用私钥对加密后的数据进行解密。以下是使用RSA私钥解密数据的代码示例：

import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;

public class RSADecryptor {
    public static void main(String[] args) {
        try {
            // 加密后的数据（Base64编码）
            String encryptedDataString = "3TiTv+AE9FF8NMMFYqx8y/Qz+uzFP/JEcsKGMJP+10r7SmNSDRsjMdK5Mbcz8zvrTaWCrIP4wmUgJhD7ZNoSmQ==";
            // 私钥字符串（Base64编码）
            String privateKeyString = "MIIBOAIBAAJALloSaH+P1Z1Q1A/qs3gejbddklEiROWf2EadwZ68GBgzHk491icoP5x24SBOweiYA+xSqNxxFxSKuWpMu922hMCAwEAAQJAB+hKDm+GF1z5soiqn8DBw7SHf/XRGlxpViWOGTm+LJ6NOkOFH0RRg/cdqq9umemQvR+E6YUcM/NzqxIqJFQyQIhAO2dNYXRKeHNmKXa5vYqWYJIJtyKXXDhLvCRukRz4WFAiEAz2jl8eXSaevi8YMnxRwYnH/OgnesWr0AFr0QemF5sECIBzvqdPKUQzzw3CHjgcTJtX9p9q/MVN4upqvtbJ2WxsNAiAYET666mlWgGIca1ePAbtoB10vhWzDY5YxQ/eTkDssCQIgNoDd1BtSVbWDEUSN/9fCP6UekytJfGFeUZerYB0UlL0=";
            
            // 将私钥字符串转换为私钥对象
            byte[] privateKeyBytes = Base64.getDecoder().decode(privateKeyString);
            PrivateKey privateKey = KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));

            // 创建RSA密码器
            Cipher cipher = Cipher.getInstance("RSA");
            // 使用私钥进行解密
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            byte[] decryptedData = cipher.doFinal(Base64.getDecoder().decode(encryptedDataString));

            // 输出解密后的数据
            String decryptedDataString = new String(decryptedData, "UTF-8");
            System.out.println("解密后的数据：" + decryptedDataString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

上述代码和加密部分的代码类似，只不过这次是使用私钥对加密后的数据进行解密。同样地，首先将私钥字符串转换为私钥对象。然后，创建RSA密码器并使用私钥进行初始化。最后，调用doFinal

Sulitkan data menggunakan kunci awam

Seterusnya, kami akan menyulitkan data menggunakan kunci awam. Berikut ialah contoh kod untuk menyulitkan data menggunakan kunci awam RSA:

rrreee🎜Kod di atas menggunakan kelas Cipher untuk penyulitan data. Mula-mula, tukar rentetan kunci awam kepada objek kunci awam. Kemudian, cipta sifir RSA dan mulakannya dengan kunci awam. Akhir sekali, panggil kaedah doFinal untuk menyulitkan data dan tukar data yang disulitkan kepada rentetan berkod Base64 untuk output. 🎜
🎜Gunakan kunci persendirian untuk menyahsulit data🎜🎜🎜Akhir sekali, kami menggunakan kunci persendirian untuk menyahsulit data yang disulitkan. Berikut ialah contoh kod menggunakan kunci persendirian RSA untuk menyahsulit data: 🎜rrreee🎜Kod di atas adalah serupa dengan kod di bahagian penyulitan, kecuali kali ini kunci persendirian digunakan untuk menyahsulit data yang disulitkan. Begitu juga, mula-mula tukar rentetan kunci persendirian menjadi objek kunci persendirian. Kemudian, cipta sifir RSA dan mulakan ia dengan kunci peribadi. Akhir sekali, panggil kaedah doFinal untuk menyahsulit data yang disulitkan dan menukar data yang dinyahsulit kepada rentetan untuk output. 🎜🎜Ringkasan🎜🎜Artikel ini memperkenalkan cara melaksanakan algoritma penyulitan RSA menggunakan bahasa Java dan menyediakan contoh kod khusus. Dengan menjana pasangan kunci, menggunakan kunci awam untuk menyulitkan data, dan menggunakan kunci persendirian untuk menyahsulit data, kami boleh melaksanakan fungsi algoritma penyulitan RSA. Saya harap artikel ini akan membantu pembaca tentang algoritma penyulitan RSA. 🎜

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan algoritma penyulitan RSA menggunakan java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!