对称加密与非对称 示例
最近了解到对称加密与非对称加密算法 就去查询了一下 发现好多写的不是很相信 总结一下 都是别人的博客 我亲测的可以使用.
简介:
对称加密: 加密和解密的秘钥使用的是同一个.
非对称加密: 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥（privatekey）。
对称加密算法: 密钥较短，破译困难，除了数据加密标准（DES），另一个对称密钥加密系统是国际数据加密算法（IDEA），它比DES的加密性好，且对计算机性能要求也没有那么高.
优点:
算法公开、计算量小、加密速度快、加密效率高
缺点:
在数据传送前，发送方和接收方必须商定好秘钥，然后 使双方都能保存好秘钥。其次如果一方的秘钥被泄露，那么加密信息也就不安全了。另外，每对用户每次使用对称加密算法时，都需要使用其他人不知道的唯一秘钥，这会使得收、发双方所拥有的钥匙数量巨大，密钥管理成为双方的负担。
常见的对称加密算法有: DES、3DES、Blowfish、IDEA、RC4、RC5、RC6 和 AES
非对称加密算法: 公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。
非对称加密算法实现机密信息交换的基本过程是：甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开；得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方；甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。
优点:
安全
缺点:
速度较慢
常见的非对称加密算法有: RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）
Hash算法（摘要算法）
Hash算法特别的地方在于它是一种单向算法，用户可以通过hash算法对目标信息生成一段特定长度的唯一hash值，却不能通过这个hash值重新获得目标信息。因此Hash算法常用在不可还原的密码存储、信息完整性校验等。
常见的摘要算法有: MD2、MD4、MD5、HAVAL、SHA
原文链接：https://blog.csdn.net/qq_29689487/article/details/81634057
非对称加密示例
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class EncrypRSA {
public static final String KEY_ALGORITHM = "RSA";
/**
* BASE64解密
*
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptBASE64(String key) throws Exception {
return (new BASE64Decoder()).decodeBuffer(key);
}
/**
* BASE64加密
*
* @param key
* @return
* @throws Exception
*/
public static String encryptBASE64(byte[] key) throws Exception {
return (new BASE64Encoder()).encodeBuffer(key);
}
/**
* 加密
*
* @param publicKey
* 公钥
* @param srcBytes
* 加密数据数组
* @return
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
protected byte[] encrypt(RSAPublicKey publicKey, byte[] srcBytes)
throws NoSuchAlgorithmException, NoSuchPaddingException,
InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
if (publicKey != null) {
// Cipher负责完成加密或解密工作，基于RSA
Cipher cipher = Cipher.getInstance("RSA");
// 根据公钥，对Cipher对象进行初始化
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] resultBytes = cipher.doFinal(srcBytes);
return resultBytes;
}
return null;
}
/**
* 解密
*
* @param privateKey
* 私钥
* @param srcBytes
* 解密数据数组
* @return
* @throws NoSuchAlgorithmException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
protected byte[] decrypt(RSAPrivateKey privateKey, byte[] srcBytes)
throws NoSuchAlgorithmException, NoSuchPaddingException,
InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
if (privateKey != null) {
// Cipher负责完成加密或解密工作，基于RSA
Cipher cipher = Cipher.getInstance("RSA");
// 根据公钥，对Cipher对象进行初始化
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] resultBytes = cipher.doFinal(srcBytes);
return resultBytes;
}
return null;
}
/**
* @param args
* @throws NoSuchAlgorithmException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws NoSuchPaddingException
* @throws InvalidKeyException
*/
public static void main(String[] args) throws NoSuchAlgorithmException,
InvalidKeyException, NoSuchPaddingException,
IllegalBlockSizeException, BadPaddingException, Exception {
EncrypRSA rsa = new EncrypRSA();
String msg = "测试加密数据：基于RSA算法生成对象";
// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
// 初始化密钥对生成器，密钥大小为1024位
keyPairGen.initialize(1024);
// 生成一个密钥对，保存在keyPair中:生成的密钥对必须是同一个KeyPair对象否则解密失败
KeyPair keyPair = keyPairGen.generateKeyPair();
// 得到公钥key
RSAPublicKey orapublicKey = (RSAPublicKey) keyPair.getPublic();
byte[] publicKeybyte = orapublicKey.getEncoded();
String publicKeyString = encryptBASE64(publicKeybyte);
System.out.println("得到公钥 : " + publicKeyString);
// 得到私钥key
RSAPrivateKey oraprivateKey = (RSAPrivateKey) keyPair.getPrivate();
byte[] privateKeybyte = oraprivateKey.getEncoded();
String privateKeyString = encryptBASE64(privateKeybyte);
System.out.println("得到私钥 : " + privateKeyString);
// 使用公私钥进行数字签名
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
// 解密由base64编码的私钥,并构造PKCS8EncodedKeySpec对象
PKCS8EncodedKeySpec privatekcs8KeySpec = new PKCS8EncodedKeySpec(
decryptBASE64(privateKeyString));
PrivateKey privateKey = keyFactory.generatePrivate(privatekcs8KeySpec);
// 解密由base64编码的公钥,并构造X509EncodedKeySpec对象
X509EncodedKeySpec publicpkcs8KeySpec = new X509EncodedKeySpec(
decryptBASE64(publicKeyString));
PublicKey publicKey = keyFactory.generatePublic(publicpkcs8KeySpec); // RSA对称加密算法
// 用公钥加密
byte[] srcBytes = msg.getBytes();
byte[] resultBytes = rsa.encrypt((RSAPublicKey) publicKey, srcBytes);
String base64Msg = encryptBASE64(resultBytes);
byte[] base64MsgD = decryptBASE64(base64Msg);
// 用私钥解密
byte[] decBytes = rsa.decrypt((RSAPrivateKey) privateKey, base64MsgD);
System.out.println("明文是:" + msg);
System.out.println("双重加密后是:" + base64Msg);
System.out.println("解密后是:" + new String(decBytes));
}
对称加密示例:
public static void main(String[] args) {
String content = "www.baidu.com";
String password = "123";
System.out.println("加密之前：" + content);
// 加密
byte[] encrypt = AESKeyPairUtils.encrypt(content, password);
System.out.println("加密后的内容：" + new String(encrypt));
// 解密
String msg = AESKeyPairUtils.decrypt(encrypt, password);
System.out.println("解密后的内容：" + new String(msg));
}
/**
* AES加密字符串
* @param content 需要被加密的字符串
* @param password 加密需要的密码
* @return 密文字符串
*/
public static byte[] encrypt(String content,String password){
try {
SecretKeySpec secretKeySpec = getSecretKeySpec(password);
Cipher cipher = Cipher.getInstance("AES");//创建密码器
cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec);
byte[] bytes = cipher.doFinal(content.getBytes("UTF-8"));
return bytes;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String decrypt(byte[] content,String password){
String msg = "";
try {
SecretKeySpec secretKeySpec = getSecretKeySpec(password);
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE,secretKeySpec);
byte[] bytes = cipher.doFinal(content);
msg = new String(bytes);
} catch (Exception e) {
e.printStackTrace();
}
return msg;
}
/**
* 获取cipher
* @param password 密码
* @return
*/
public static SecretKeySpec getSecretKeySpec(String password){
try {
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(128,new SecureRandom(password.getBytes()));
SecretKey secretKey = keyGenerator.generateKey();
System.out.println("secretkey:"+ Base64.encodeBase64String(secretKey.getEncoded()));
SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getEncoded(),"AES");
return secretKeySpec;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
这两个示例都是别的博主写的 本人亲测可以使用 但是示例的连接忘记了(请作者君见谅,小弟疏忽大意) 若作者看见 请勿见怪