rsa加密的传递与接收

java 加密数据，go解析数据

java 加密

public static String PUBLIC = "MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALAEZjmAtbVl5534yrDD4n5UUcH1NdNL\nTQzEPojUvf4/o7cv2dGZJ5QdJ/ciUjIwWZpF2qtBKQpye/LwAYC5WLUCAwEAAQ==";
public static String publicEncode(String message) throws Exception {
    return RSAUtil.encrypt(message, PUBLIC);
}

go 解密

// 计算秘钥
sign, err := base64.StdEncoding.DecodeString(message.Sign)
if err != nil {
	return nil, nil, err
}
secret, err := PrivateDecrypt(sign, PRIVATE)
if err != nil {
	return nil, nil, err
}
log.Infof("获取秘钥： %s", string(secret))

// 解密
func PrivateDecrypt(ciphertext, privateKey []byte) ([]byte, error) {
	priv, err := ParsePrivateKey(privateKey)
	if err != nil {
		return nil, err
	}

	var b bytes.Buffer

	begin, size, end := 0, 128, len(ciphertext)

	for end-begin > 0 {
		var temp []byte
		if end <= begin+size {
			temp = ciphertext[begin:end]
		} else {
			temp = ciphertext[begin : begin+size]
		}
		tres, err := rsa.DecryptPKCS1v15(rand.Reader, priv, temp)
		if err != nil {
			return nil, err
		}
		b.Write(tres)
		begin += size
	}

	return b.Bytes(), err
}

func ParsePrivateKey(private []byte) (*rsa.PrivateKey, error) {
	block, _ := pem.Decode(private)
	if block == nil {
		return nil, privateDecodeErr
	}
	priv, err := x509.ParsePKCS1PrivateKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	return priv, nil
}

public class RSAUtil {

    public static void main(String[] args) {

        try {
//            String publicKey = "0182C9D337EA20322570E837F1C141056EB4A324672388B99E220206E637BF2E2088A5CC530E6923D59C630E8442AAD8292B7DC6BFE92BE1AD9C569F5B39D629AC56013F5F9BB442FFD151FA7D91E221D1C6247A8DE5AC0382A3E716E5B8665B72A1DDBACD85AB87D3FE6DA36946D9C52288B8D6B38C10C4771E5D113BCF535BEA3AAF55";
//            RSAPublicKey publicKey1 = getPublicKey(publicKey);
//            System.out.println("这是公钥："+publicKey);
//            String privateKey = "6D7508E54298A18C67D97BBF226AB414050BC785BA7C0AD1FA5131AC177371725B00D8F9103381AD3A4584B2C585993DBCDA1E43CA4EE4ADC4B13F0C7343F926BC";
//            RSAPrivateKey privateKey1 = getPrivateKey(privateKey);
//            System.out.println("这是私钥："+privateKey);

            Map keys = generateKeyPair();
            String publicKey = (String) keys.get("publicKey");
            // MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAImFCSfUU3FC6Wk00405LXOsk8cTL0zr9lvFoMTdtAfBKQHLQgmadvCt+HZRuVt5JdQuCEsVvbZh459IWo4HqMsCAwEAAQ==

            // MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAL9HBy/bGGBR/LuM9+m7JwZBaZc8gzD7IaW/m+F6e+aC9n+uzQjGqWOwhkDKoFYTSFygzNY3nNI8CjoIsV18DWUCAwEAAQ==

            PublicKey publicKey1 = getPublicKey(publicKey);
            String privateKey = (String) keys.get("privateKey");
            // MIIBUwIBADANBgkqhkiG9w0BAQEFAASCAT0wggE5AgEAAkEAiYUJJ9RTcULpaTTTjTktc6yTxxMvTOv2W8WgxN20B8EpActCCZp28K34dlG5W3kl1C4ISxW9tmHjn0hajgeoywIDAQABAkAzX7q64WxGvKt7/Rsm//xF4WvXjAg4oVIImLzlrrlJx8HrlFkPTMBLEpd+4SZgOCfN3NHFFeoPGJxttfPV5GRJAiEA/Qi5lq6YbLz3jYCrV6NZgbKxeOCLnDwbzkcIHXWwSfUCIQCLIbBN/taWhsne9MPNikHKe+0tfpkSO3ohCAwxN+qvvwIgFJQrE9grSVys/XMjfEMqumOgD2ajtBcnY8VfIZY6uikCIHjSw7mn8hB8czjElHmddC70We8lPqb/sbqXs4bWiV8fAiAThY+Oswv2zDhGxm0wca0n6U08YaVCL4dr0BfVTfJrIA==
            // MIIBOgIBAAJBAL9HBy/bGGBR/LuM9+m7JwZBaZc8gzD7IaW/m+F6e+aC9n+uzQjGqWOwhkDKoFYTSFygzNY3nNI8CjoIsV18DWUCAwEAAQJAdS932LrbIU+5jdHcpMazLuLuZOh+24hP4fMU9jwLInozr67gGxT1RHwH9WFTQLWN8cWYzJJI+2fx8IKy/7Ps1QIhAO/6GgU4q9uwegsQw7Wen4xp915iYZBnK9/dQWvR8+QfAiEAzAyC7EIMbhCMVI2ftkY8ZK9Q2NV1HJiOTgA/L9oAPfsCIGm1rSKhrSqwGYKoVt25SyTqRNph0gJvQCdz6m6ZZKsXAiBnsRP3K7lVVWN6tF2tKxQVtmHHTvIsjfoC+W0izA3DcQIhAK1WeQ5WqRSVNCgnNlFleEymR4uThss+nNsV65YmgJVs==
            PrivateKey privateKey1 = getPrivateKey(privateKey);
            System.out.println("这是生成的公钥：" + publicKey);
            System.out.println("这是生成的私钥：" + privateKey);


            String mes = "********";
            System.out.println("这是明文：" + mes);

            String miwen = encrypt(mes, publicKey);
            System.out.println("这是密文：" + miwen);

            String minwen = decrypt(miwen, privateKey);
            System.out.println("这是明文：" + minwen);



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

    }
    private static final Logger log = Logger.getLogger(RSA.class);
    /** 指定key的大小 */
    private static int KEYSIZE = 512;
    /**
     * 生成密钥对
     */
    public static Map<String, String> generateKeyPair() throws Exception {
        /** RSA算法要求有一个可信任的随机数源 */
        SecureRandom sr = new SecureRandom();
        /** 为RSA算法创建一个KeyPairGenerator对象 */
        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
        /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
        kpg.initialize(KEYSIZE, sr);
        /** 生成密匙对 */
        KeyPair kp = kpg.generateKeyPair();
        /** 得到公钥 */
        Key publicKey = kp.getPublic();
        byte[] publicKeyBytes = publicKey.getEncoded();
        String pub = new String(Base64.encodeBase64(publicKeyBytes),
                "UTF-8");
        /** 得到私钥 */
        Key privateKey = kp.getPrivate();
        byte[] privateKeyBytes = privateKey.getEncoded();
        String pri = new String(Base64.encodeBase64(privateKeyBytes),
                "UTF-8");

        Map<String, String> map = new HashMap<String, String>();
        map.put("publicKey", pub);
        map.put("privateKey", pri);
        RSAPublicKey rsp = (RSAPublicKey) kp.getPublic();
        BigInteger bint = rsp.getModulus();
        byte[] b = bint.toByteArray();
        byte[] deBase64Value = Base64.encodeBase64(b);
        String retValue = new String(deBase64Value);
        map.put("modulus", retValue);
        return map;
    }

    /**
     * 加密方法 source： 源数据
     */
    public static String encrypt(String source, String publicKey)
            throws Exception {
        Key key = getPublicKey(publicKey);
        /** 得到Cipher对象来实现对源数据的RSA加密 */
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] b = source.getBytes();
        /** 执行加密操作 */
        byte[] b1 = cipher.doFinal(b);
        return new String(Base64.encodeBase64(b1),
                "UTF-8");
    }

    /**
     * 解密算法 cryptograph:密文
     */
    public static String decrypt(String cryptograph, String privateKey)
            throws Exception {

        Key key = getPrivateKey(privateKey);
        /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] b1 = Base64.decodeBase64(cryptograph.getBytes());
        /** 执行解密操作 */
        byte[] b = cipher.doFinal(b1);
        return new String(b);
    }

    /**
     * 得到公钥
     *
     * @param key
     *            密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static PublicKey getPublicKey(String key) throws Exception {
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(
                Base64.decodeBase64(key.getBytes()));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 得到私钥
     *
     * @param key
     *            密钥字符串（经过base64编码）
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String key) throws Exception {
        java.security.Security.addProvider(
                new org.bouncycastle.jce.provider.BouncyCastleProvider()
        );
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(
                Base64.decodeBase64(key.getBytes()));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    public static String sign(String content, String privateKey) {
        String charset = "UTF-8";
        try {
            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(
                    Base64.decodeBase64(privateKey.getBytes()));
            KeyFactory keyf = KeyFactory.getInstance("RSA");
            PrivateKey priKey = keyf.generatePrivate(priPKCS8);

            Signature signature = Signature.getInstance("SHA1WithRSA");

            signature.initSign(priKey);
            signature.update(content.getBytes(charset));

            byte[] signed = signature.sign();

            return new String(Base64.encodeBase64(signed));
        } catch (Exception e) {

        }

        return null;
    }
//
//    public static boolean checkSign(String content, String sign, String publicKey)
//    {
//        try
//        {
//            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
//            byte[] encodedKey = Base64.decode2(publicKey);
//            PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
//
//
//            java.security.Signature signature = java.security.Signature
//                    .getInstance("SHA1WithRSA");
//
//            signature.initVerify(pubKey);
//            signature.update( content.getBytes("utf-8") );
//
//            boolean bverify = signature.verify( Base64.decode2(sign) );
//            return bverify;
//
//        }
//        catch (Exception e)
//        {
//            log.error(e.getMessage(), e);
//        }
//
//        return false;
//    }

}