Java和Go語言之間進行公鑰加密和解密

Go語言本身支援RSA加密算法，可以使用Go語言内置的crypto/rsa庫進行公鑰加密。但是，由于Java和Go語言在編碼方式、位元組序等方面存在差異，是以需要一些額外的處理才能在Java和Go語言之間進行公鑰加密和解密。

具體步驟如下：

1. 生成RSA公私鑰對

可以使用Java或Go語言生成RSA公私鑰對，這裡以Java為例：

KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(2048);
KeyPair keyPair = keyPairGenerator.generateKeyPair();

PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();

byte[] publicKeyBytes = publicKey.getEncoded(); // 公鑰的位元組數組
byte[] privateKeyBytes = privateKey.getEncoded(); // 私鑰的位元組數組
           

1. 将Java格式的公鑰轉換為Go語言格式的公鑰

Java的公鑰格式為X.509格式，需要将其轉換為Go語言支援的PKCS1格式。可以使用以下代碼将Java公鑰轉換為Go語言公鑰：

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);

byte[] goPublicKeyBytes = rsaPublicKey.getModulus().toByteArray();
if (goPublicKeyBytes[0] == 0) {
    byte[] tmp = new byte[goPublicKeyBytes.length - 1];
    System.arraycopy(goPublicKeyBytes, 1, tmp, 0, tmp.length);
    goPublicKeyBytes = tmp;
}
           

1. 使用Go語言的公鑰加密資料

使用Go語言内置的crypto/rsa庫進行公鑰加密。具體代碼如下：

func encrypt(publicKeyBytes []byte, plainText []byte) ([]byte, error) {
    block, _ := pem.Decode(publicKeyBytes)
    if block == nil {
        return nil, fmt.Errorf("failed to decode PEM block")
    }

    pub, err := x509.ParsePKCS1PublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }

    cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, pub, plainText)
    if err != nil {
        return nil, err
    }

    return cipherText, nil
}
           

其中，publicKeyBytes為Go語言格式的公鑰位元組數組，plainText為待加密的資料。

完整示例代碼如下：

import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class Main {
    public static void main(String[] args) throws Exception {
        // 生成RSA公私鑰對
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

        byte[] publicKeyBytes = publicKey.getEncoded(); // 公鑰的位元組數組
        byte[] privateKeyBytes = privateKey.getEncoded(); // 私鑰的位元組數組

        // 将Java格式的公鑰轉換為Go語言格式的公鑰
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);

        byte[] goPublicKeyBytes = rsaPublicKey.getModulus().toByteArray();
        if (goPublicKeyBytes[0] == 0) {
            byte[] tmp = new byte[goPublicKeyBytes.length - 1];
            System.arraycopy(goPublicKeyBytes, 1, tmp, 0, tmp.length);
            goPublicKeyBytes = tmp;
        }

        // 使用Go語言的公鑰加密資料
        String plainText = "Hello, world!";
        byte[] cipherText = encrypt(goPublicKeyBytes, plainText.getBytes("UTF-8"));

        // 輸出加密後的資料
        System.out.println(Base64.getEncoder().encodeToString(cipherText));
    }

    private static byte[] encrypt(byte[] publicKeyBytes, byte[] plainText) throws Exception {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

        // 将Go語言格式的公鑰轉換為Java格式的公鑰
        byte[] pemPublicKeyBytes = pemEncode(publicKeyBytes);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pemPublicKeyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

        // 使用Java的公鑰加密資料
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(plainText);
    }

    private static byte[] pemEncode(byte[] derBytes) {
        final byte[] pemPrefixBytes = "-----BEGIN PUBLIC KEY-----\n".getBytes();
        final byte[] pemSuffixBytes = "\n-----END PUBLIC KEY-----\n".getBytes();

        byte[] pemBytes = new byte[pemPrefixBytes.length + pemSuffixBytes.length + ((derBytes.length + 2) / 3) * 4];
        int pemIndex = 0;

        System.arraycopy(pemPrefixBytes, 0, pemBytes, pemIndex, pemPrefixBytes.length);
        pemIndex += pemPrefixBytes.length;

        Base64.Encoder encoder = Base64.getMimeEncoder(64, new byte[]{'\n'});
        pemIndex += encoder.encode(derBytes, 0, derBytes.length, pemBytes, pemIndex);

        System.arraycopy(pemSuffixBytes, 0, pemBytes, pemIndex, pemSuffixBytes.length);
        pemIndex += pemSuffixBytes.length;

        return pemBytes;
    }
}
           

需要注意的是，Java和Go語言在編碼方式、位元組序等方面存在差異，需要進行一些額外的處理才能在Java和Go語言之間進行公鑰加密和解密。同時，由于Java和Go語言在實作上的差異，使用Java格式的公鑰進行加密可能會比使用Go語言格式的公鑰進行加密慢。