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语言格式的公钥进行加密慢。