1. 什么是對稱式加密和非對稱式加密

　　對稱式加密：解密方式是加密方式的逆運算，即加密和解密使用的是同一個密鑰（初等加密算法）。

　　非對稱式加密：加密和解密需要兩個密鑰進行，這兩個密鑰是公鑰和私鑰（高等加密算法）。

　　2. 對稱式加密和非對稱式加密的主要實現(xiàn)方式

　　對稱式加密主要實現(xiàn)方式：

　　1） DES（Data Encryption Standard）：安全性較差，一般不建議使用。

　　2） 3DES：三重DES，針對DES密鑰長度較短的問題，3DES可以實現(xiàn)最少112位、最高168位密鑰長度。

　　3） AES：相比于3DES擁有更好的安全性。

　　4） PBE（Password Based Encryption）：基于口令的加密，結合了DES和AES的優(yōu)點。

　　非對稱式加密主要實現(xiàn)方式：

　　1） DH（Diffie-Hellman）：密鑰交換算法。

　　2） RSA：基于因子分解。

　　3） ElGamal：基于離散對數(shù)。

　　4） ECC（Elliptical Curve Cryptography）：橢圓曲線加密。

　　3. 對稱式加密在JAVA中的實現(xiàn)（PBE加密）：

　　［java］ view plain copypublic class PBE {

　　private static String src=“security with PBE”;

　　public static void main（String［］ args）{

　　jdkPBE（）;

　　}

　　public static void jdkPBE（）{

　　try {

　　//初始化鹽（擾碼）

　　SecureRandom random=new SecureRandom（）;

　　byte［］ salt=random.generateSeed（8）;

　　//口令與密鑰

　　String password=“CSDN”;

　　PBEKeySpec pbeKeySpec=new PBEKeySpec（password.toCharArray（））;

　　SecretKeyFactory factory=SecretKeyFactory.getInstance（“PBEWITHMD5andEDS”）;

　　Key key=factory.generateSecret（pbeKeySpec）;

　　//加密

　　PBEParameterSpec pbeParameterSpec=new PBEParameterSpec（salt，100）;//參數(shù)1.鹽，參數(shù)2.迭代次數(shù)

　　Cipher cipher=Cipher.getInstance（“PBEWITHMD5andEDS”）;

　　cipher.init（Cipher.ENCRYPT_MODE，key，pbeParameterSpec）;

　　byte［］ result=cipher.doFinal（src.getBytes（））;

　　System.out.println（“jdk pbe encrypt：” + Base64.encodeToString（result，1））;

　　//解密

　　cipher.init（Cipher.DECRYPT_MODE，key，pbeParameterSpec）;

　　result=cipher.doFinal（result）;

　　System.out.println（“jdk pbe decrypt：”+new String（result））;

　　} catch （Exception e） {

　　e.printStackTrace（）;

　　}

　　}

　　}

　　4. 非對稱式加密在JAVA中的實現(xiàn)（DH加密）：

　?。踛ava］ view plain copypublic class DH {

　　private static String src=“security with DH”;

　　public static void main（String［］ args）{

　　jdkDH（）;

　　}

　　public static void jdkDH（）{

　　try {

　　//初始化發(fā)送方密鑰

　　KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance（“DH”）;

　　senderKeyPairGenerator.initialize（512）;

　　KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair（）;

　　byte［］ senderPublicKeyEnc=senderKeyPair.getPublic（）.getEncoded（）;

　　//初始化接收方密鑰

　　KeyFactory receiverKeyFactory=KeyFactory.getInstance（“DH”）;

　　X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec（senderPublicKeyEnc）;

　　PublicKey receiverPublicKey=receiverKeyFactory.generatePublic（x509EncodedKeySpec）;

　　DHParameterSpec dhParameterSpec=（（DHPublicKey）receiverPublicKey）.getParams（）;

　　KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance（“DH”）;

　　receiverKeyPairGenerator.initialize（dhParameterSpec）;

　　KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair（）;

　　PrivateKey receiverPrivateKey=receiverKeyPair.getPrivate（）;

　　byte［］ receiverPublicKeyEnc =receiverKeyPair.getPublic（）.getEncoded（）;

　　//密鑰構建

　　KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance（“DH”）;

　　receiverKeyAgreement.init（receiverPrivateKey）;

　　receiverKeyAgreement.doPhase（receiverPublicKey， true）;

　　SecretKey receiverDesKey=receiverKeyAgreement.generateSecret（“DES”）;

　　KeyFactory senderKeyFactory=KeyFactory.getInstance（“DH”）;

　　x509EncodedKeySpec=new X509EncodedKeySpec（receiverPublicKeyEnc）;

　　PublicKey senderPublicKey=senderKeyFactory.generatePublic（x509EncodedKeySpec）;

　　KeyAgreement senderKeyAgreement=KeyAgreement.getInstance（“DH”）;

　　senderKeyAgreement.init（senderKeyPair.getPrivate（））;

　　senderKeyAgreement.doPhase（senderPublicKey， true）;

　　SecretKey senderDesKey=senderKeyAgreement.generateSecret（“DES”）;

　　if（Objects.equals（receiverDesKey，senderDesKey））{

　　System.out.println（“雙方密鑰相同”）;

　　}

　　//加密

　　Cipher cipher=Cipher.getInstance（“DES”）;

　　cipher.init（Cipher.ENCRYPT_MODE，senderDesKey）;

　　byte［］ result=cipher.doFinal（src.getBytes（））;

　　System.out.println（“jdk dh encrypt：”+Base64.encodeToString（result，1））;

　　//解密

　　cipher=Cipher.getInstance（“DES”）;

　　cipher.init（Cipher.DECRYPT_MODE，receiverDesKey）;

　　result=cipher.doFinal（result）;

　　System.out.println（“jdk dh encrypt：”+new String（result））;

　　} catch （Exception e） {

　　e.printStackTrace（）;

　　}

　　}

　　}

　　5. 非對稱式加密在JAVA中的實現(xiàn)（RSA加密）：

　?。踛ava］ view plain copypublic class RSA {

　　private static String src=“security with rsa”;

　　public static void main（String［］ args）{

　　jdkRSA（）;

　　}

　　public static void jdkRSA（）{

　　try {

　　//初始化密鑰

　　KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance（“RSA”）;

　　keyPairGenerator.initialize（512）;//64的整倍數(shù)，512~65536

　　KeyPair keyPair=keyPairGenerator.generateKeyPair（）;

　　RSAPrivateKey rsaPrivateKey= （RSAPrivateKey） keyPair.getPrivate（）;

　　RSAPublicKey rsaPublicKey= （RSAPublicKey） keyPair.getPublic（）;

　　System.out.println（“Public key：”+ Base64.encodeToString（rsaPrivateKey.getEncoded（），1））;

　　System.out.println（“Private key：”+ Base64.encodeToString（rsaPrivateKey.getEncoded（），1））;

　　//私鑰加密，公鑰解密——加密

　　PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec（rsaPrivateKey.getEncoded（））;

　　KeyFactory keyFactory=KeyFactory.getInstance（“RSA”）;

　　PrivateKey privateKey=keyFactory.generatePrivate（pkcs8EncodedKeySpec）;

　　Cipher cipher=Cipher.getInstance（“RSA”）;

　　cipher.init（Cipher.ENCRYPT_MODE， privateKey）;

　　byte［］ result=cipher.doFinal（src.getBytes（））;

　　System.out.println（“私鑰加密，公鑰解密——加密：”+Base64.encodeToString（result，1））;

　　//私鑰加密，公鑰解密——解密

　　X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec（rsaPublicKey.getEncoded（））;

　　keyFactory=KeyFactory.getInstance（“RSA”）;

　　PublicKey publicKey=keyFactory.generatePublic（x509EncodedKeySpec）;

　　cipher=Cipher.getInstance（“RSA”）;

　　cipher.init（Cipher.DECRYPT_MODE，publicKey）;

　　result=cipher.doFinal（result）;

　　System.out.println（new String（result））;

　　//公鑰加密，私鑰解密——加密

　　x509EncodedKeySpec=new X509EncodedKeySpec（rsaPublicKey.getEncoded（））;

　　keyFactory=KeyFactory.getInstance（“RSA”）;

　　publicKey=keyFactory.generatePublic（x509EncodedKeySpec）;

　　cipher=Cipher.getInstance（“RSA”）;

　　cipher.init（Cipher.ENCRYPT_MODE，publicKey）;

　　result=cipher.doFinal（src.getBytes（））;

　　System.out.println（“鑰加密，私鑰解密——加密：”+Base64.encodeToString（result，1））;

　　//公鑰加密，私鑰解密——解密

　　pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec（rsaPrivateKey.getEncoded（））;

　　keyFactory=KeyFactory.getInstance（“RSA”）;

　　privateKey=keyFactory.generatePrivate（pkcs8EncodedKeySpec）;

　　cipher=Cipher.getInstance（“RSA”）;

　　cipher.init（Cipher.DECRYPT_MODE，privateKey）;

　　cipher.doFinal（result）;

　　System.out.println（“公鑰加密，私鑰解密——解密：” + Base64.encodeToString（result， 1））;

　　} catch （Exception e） {

　　e.printStackTrace（）;

　　}

　　}

　　}

　　6、RSA非對稱加密算法

　　唯一廣泛接受并實現(xiàn)

　　數(shù)據(jù)加密&數(shù)字簽名

　　既可公鑰加密，私鑰解密

　　又可私鑰加密，公鑰解密

　　代碼實現(xiàn)

　　try {

　　//初始化秘鑰

　　KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance（“RSA”）;

　　keyPairGenerator.initialize（512）;

　　KeyPair keyPair = keyPairGenerator.generateKeyPair（）;

　　RSAPublicKey rsaPublicKey = （RSAPublicKey）keyPair.getPublic（）;

　　RSAPrivateKey rsaPrivateKey = （RSAPrivateKey）keyPair.getPrivate（）;

　　//私鑰加密，公鑰解密--加密

　　PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec（rsaPrivateKey.getEncoded（））;

　　KeyFactory factory = KeyFactory.getInstance（“RSA”）;

　　PrivateKey privateKey = factory.generatePrivate（pkcs8EncodedKeySpec）;

　　Cipher cipher = Cipher.getInstance（“RSA”）;

　　cipher.init（Cipher.ENCRYPT_MODE， privateKey）;

　　byte［］ result = cipher.doFinal（str.getBytes（））;

　　System.out.println（“私加公解 rsa en：”+Base64.toBase64String（result））;

　　//私鑰加密，公鑰解密--解密

　　X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec（rsaPublicKey.getEncoded（））;

　　factory = KeyFactory.getInstance（“RSA”）;

　　PublicKey publicKey = factory.generatePublic（x509EncodedKeySpec）;

　　cipher = Cipher.getInstance（“RSA”）;

　　cipher.init（Cipher.DECRYPT_MODE， publicKey）;

　　byte［］ raw = cipher.doFinal（result）;

　　System.out.println（“私加公解 rsa de：”+ new String（raw））;

　　//公鑰加密，私鑰解密--加密

　　cipher.init（Cipher.ENCRYPT_MODE， publicKey）;

　　byte［］ result2 = cipher.doFinal（str.getBytes（））;

　　System.out.println（“公加私解 rsa en：”+Base64.toBase64String（result2））;

　　//公鑰加密，私鑰解密--解密

　　cipher.init（Cipher.DECRYPT_MODE， privateKey）;

　　byte［］ raw2 = cipher.doFinal（result2）;

　　System.out.println（“公加私解 rsa de：” + new String （raw2））;

　　} catch （Exception e） {

　　// TODO Auto-generated catch block

　　e.printStackTrace（）;

　　}