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;
// }
}