java对称加密和非对称加密（PBE、DH、RSA）

1.       什么是对称式加密和非对称式加密

对称式加密：解密方式是加密方式的逆运算，即加密和解密使用的是同一个密钥（初等加密算法）。

非对称式加密：加密和解密需要两个密钥进行，这两个密钥是公钥和私钥（高等加密算法）。

2.       对称式加密和非对称式加密的主要实现方式

对称式加密主要实现方式：

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

2）  3DES：三重DES，针对DES密钥长度较短的问题，3DES可以实现最少112位、最高168位密钥长度。

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

4）  PBE（Password Based Encryption）：基于口令的加密，结合了DES和AES的优点。

非对称式加密主要实现方式：

1）  DH（Diffie-Hellman）：密钥交换算法。

2）  RSA：基于因子分解。

3）  ElGamal：基于离散对数。

4）  ECC（Elliptical Curve Cryptography）：椭圆曲线加密。

3.       对称式加密和非对称式加密的对比

非对称加密与对称加密相比，其安全性更好：对称加密的通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步密钥。

4.       对称式加密在Java中的实现（PBE加密）：

[java]viewplaincopyprint?

1.  public class PBE {  

2.      private static String src="security with PBE";  

3.      public static void main(String[] args){  

4.          jdkPBE();  

5.      }  

6.    

7.      public static void jdkPBE(){  

8.          try {  

9.              //初始化盐（扰码）  

10.             SecureRandom random=new SecureRandom();  

11.             byte[] salt=random.generateSeed(8);  

12.   

13.             //口令与密钥  

14.             String password="CSDN";  

15.             PBEKeySpec pbeKeySpec=new PBEKeySpec(password.toCharArray());  

16.             SecretKeyFactory factory=SecretKeyFactory.getInstance("PBEWITHMD5andEDS");  

17.             Key key=factory.generateSecret(pbeKeySpec);  

18.   

19.             //加密  

20.             PBEParameterSpec pbeParameterSpec=new PBEParameterSpec(salt,100);//参数1.盐，参数2.迭代次数  

21.             Cipher cipher=Cipher.getInstance("PBEWITHMD5andEDS");  

22.             cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);  

23.             byte[] result=cipher.doFinal(src.getBytes());  

24.             System.out.println("jdk pbe encrypt:" + Base64.encodeToString(result,1));  

25.   

26.             //解密  

27.             cipher.init(Cipher.DECRYPT_MODE,key,pbeParameterSpec);  

28.             result=cipher.doFinal(result);  

29.             System.out.println("jdk pbe decrypt:"+new String(result));  

30.         } catch (Exception e) {  

31.             e.printStackTrace();  

32.         }  

33.     }  

34. }  

public class PBE {

    private static Stringsrc="security with PBE";

    public static void main(String[]args){

        jdkPBE();

    }

 

    public static void jdkPBE(){

        try {

            //初始化盐（扰码）

            SecureRandom random=newSecureRandom();

            byte[]salt=random.generateSeed(8);

 

            //口令与密钥

            Stringpassword="CSDN";

            PBEKeySpecpbeKeySpec=new PBEKeySpec(password.toCharArray());

            SecretKeyFactoryfactory=SecretKeyFactory.getInstance("PBEWITHMD5andEDS");

            Keykey=factory.generateSecret(pbeKeySpec);

 

            //加密

            PBEParameterSpecpbeParameterSpec=new PBEParameterSpec(salt,100);//参数1.盐，参数2.迭代次数

            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();

        }

    }

}

5.      非对称式加密在JAVA中的实现（DH加密）：

[java]viewplaincopyprint?

1.  public class DH {  

2.      private static String src="security with DH";  

3.      public static void main(String[] args){  

4.          jdkDH();  

5.      }  

6.    

7.      public static void jdkDH(){  

8.          try {  

9.              //初始化发送方密钥  

10.             KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");  

11.             senderKeyPairGenerator.initialize(512);  

12.             KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();  

13.             byte[] senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();  

14.   

15.             //初始化接收方密钥  

16.             KeyFactory receiverKeyFactory=KeyFactory.getInstance("DH");  

17.             X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);  

18.             PublicKey receiverPublicKey=receiverKeyFactory.generatePublic(x509EncodedKeySpec);  

19.             DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();  

20.             KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");  

21.             receiverKeyPairGenerator.initialize(dhParameterSpec);  

22.             KeyPair receiverKeyPair=receiverKeyPairGenerator.generateKeyPair();  

23.             PrivateKey receiverPrivateKey=receiverKeyPair.getPrivate();  

24.             byte[] receiverPublicKeyEnc =receiverKeyPair.getPublic().getEncoded();  

25.   

26.             //密钥构建  

27.             KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");  

28.             receiverKeyAgreement.init(receiverPrivateKey);  

29.             receiverKeyAgreement.doPhase(receiverPublicKey, true);  

30.             SecretKey receiverDesKey=receiverKeyAgreement.generateSecret("DES");  

31.   

32.             KeyFactory senderKeyFactory=KeyFactory.getInstance("DH");  

33.             x509EncodedKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);  

34.             PublicKey senderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);  

35.             KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");  

36.             senderKeyAgreement.init(senderKeyPair.getPrivate());  

37.             senderKeyAgreement.doPhase(senderPublicKey, true);  

38.             SecretKey senderDesKey=senderKeyAgreement.generateSecret("DES");  

39.             if(Objects.equals(receiverDesKey,senderDesKey)){  

40.                 System.out.println("双方密钥相同");  

41.             }  

42.   

43.             //加密  

44.             Cipher cipher=Cipher.getInstance("DES");  

45.             cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);  

46.             byte[] result=cipher.doFinal(src.getBytes());  

47.             System.out.println("jdk dh encrypt:"+Base64.encodeToString(result,1));  

48.   

49.             //解密  

50.             cipher=Cipher.getInstance("DES");  

51.             cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);  

52.             result=cipher.doFinal(result);  

53.             System.out.println("jdk dh encrypt:"+new String(result));  

54.   

55.         } catch (Exception e) {  

56.             e.printStackTrace();  

57.         }  

58.     }  

59. }  

public class DH {

    private static Stringsrc="security with DH";

    public static void main(String[]args){

        jdkDH();

    }

 

    public static void jdkDH(){

        try {

            //初始化发送方密钥

            KeyPairGeneratorsenderKeyPairGenerator=KeyPairGenerator.getInstance("DH");

           senderKeyPairGenerator.initialize(512);

            KeyPairsenderKeyPair=senderKeyPairGenerator.generateKeyPair();

            byte[]senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();

 

            //初始化接收方密钥

            KeyFactoryreceiverKeyFactory=KeyFactory.getInstance("DH");

            X509EncodedKeySpecx509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);

            PublicKeyreceiverPublicKey=receiverKeyFactory.generatePublic(x509EncodedKeySpec);

            DHParameterSpecdhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();

            KeyPairGeneratorreceiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");

           receiverKeyPairGenerator.initialize(dhParameterSpec);

            KeyPairreceiverKeyPair=receiverKeyPairGenerator.generateKeyPair();

            PrivateKeyreceiverPrivateKey=receiverKeyPair.getPrivate();

            byte[]receiverPublicKeyEnc =receiverKeyPair.getPublic().getEncoded();

 

            //密钥构建

            KeyAgreementreceiverKeyAgreement = KeyAgreement.getInstance("DH");

           receiverKeyAgreement.init(receiverPrivateKey);

            receiverKeyAgreement.doPhase(receiverPublicKey,true);

            SecretKeyreceiverDesKey=receiverKeyAgreement.generateSecret("DES");

 

            KeyFactorysenderKeyFactory=KeyFactory.getInstance("DH");

            x509EncodedKeySpec=newX509EncodedKeySpec(receiverPublicKeyEnc);

            PublicKeysenderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);

            KeyAgreementsenderKeyAgreement=KeyAgreement.getInstance("DH");

           senderKeyAgreement.init(senderKeyPair.getPrivate());

           senderKeyAgreement.doPhase(senderPublicKey, true);

            SecretKeysenderDesKey=senderKeyAgreement.generateSecret("DES");

           if(Objects.equals(receiverDesKey,senderDesKey)){

               System.out.println("双方密钥相同");

            }

 

            //加密

            Ciphercipher=Cipher.getInstance("DES");

           cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);

            byte[]result=cipher.doFinal(src.getBytes());

           System.out.println("jdk dhencrypt:"+Base64.encodeToString(result,1));

 

            //解密

           cipher=Cipher.getInstance("DES");

           cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);

           result=cipher.doFinal(result);

            System.out.println("jdk dhencrypt:"+new String(result));

 

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

6.      非对称式加密在JAVA中的实现（RSA加密）：

[java]viewplaincopyprint?

1.  public class RSA {  

2.      private static String src="security with rsa";  

3.      public static void main(String[] args){  

4.          jdkRSA();  

5.      }  

6.    

7.      public static void jdkRSA(){  

8.          try {  

9.              //初始化密钥  

10.             KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA");  

11.             keyPairGenerator.initialize(512);//64的整倍数，512~65536  

12.             KeyPair keyPair=keyPairGenerator.generateKeyPair();  

13.             RSAPrivateKey rsaPrivateKey= (RSAPrivateKey) keyPair.getPrivate();  

14.             RSAPublicKey rsaPublicKey= (RSAPublicKey) keyPair.getPublic();  

15.             System.out.println("Public key:"+ Base64.encodeToString(rsaPrivateKey.getEncoded(),1));  

16.             System.out.println("Private key:"+ Base64.encodeToString(rsaPrivateKey.getEncoded(),1));  

17.   

18.             //私钥加密，公钥解密——加密  

19.             PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());  

20.             KeyFactory keyFactory=KeyFactory.getInstance("RSA");  

21.             PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);  

22.             Cipher cipher=Cipher.getInstance("RSA");  

23.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);  

24.             byte[] result=cipher.doFinal(src.getBytes());  

25.             System.out.println("私钥加密，公钥解密——加密:"+Base64.encodeToString(result,1));  

26.   

27.             //私钥加密，公钥解密——解密  

28.             X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());  

29.             keyFactory=KeyFactory.getInstance("RSA");  

30.             PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);  

31.             cipher=Cipher.getInstance("RSA");  

32.             cipher.init(Cipher.DECRYPT_MODE,publicKey);  

33.             result=cipher.doFinal(result);  

34.             System.out.println(new String(result));  

35.   

36.             //公钥加密，私钥解密——加密  

37.             x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());  

38.             keyFactory=KeyFactory.getInstance("RSA");  

39.             publicKey=keyFactory.generatePublic(x509EncodedKeySpec);  

40.             cipher=Cipher.getInstance("RSA");  

41.             cipher.init(Cipher.ENCRYPT_MODE,publicKey);  

42.             result=cipher.doFinal(src.getBytes());  

43.             System.out.println("钥加密，私钥解密——加密:"+Base64.encodeToString(result,1));  

44.   

45.             //公钥加密，私钥解密——解密  

46.             pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());  

47.             keyFactory=KeyFactory.getInstance("RSA");  

48.             privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);  

49.             cipher=Cipher.getInstance("RSA");  

50.             cipher.init(Cipher.DECRYPT_MODE,privateKey);  

51.             cipher.doFinal(result);  

52.             System.out.println("公钥加密，私钥解密——解密:" + Base64.encodeToString(result, 1));  

53.   

54.         } catch (Exception e) {  

55.             e.printStackTrace();  

56.         }  

57.     }  

58. }  

public class RSA {

    private static Stringsrc="security with rsa";

    public static void main(String[]args){

        jdkRSA();

    }

 

    public static void jdkRSA(){

        try {

            //初始化密钥

            KeyPairGeneratorkeyPairGenerator=KeyPairGenerator.getInstance("RSA");

           keyPairGenerator.initialize(512);//64的整倍数，512~65536

            KeyPairkeyPair=keyPairGenerator.generateKeyPair();

            RSAPrivateKeyrsaPrivateKey= (RSAPrivateKey) keyPair.getPrivate();

            RSAPublicKeyrsaPublicKey= (RSAPublicKey) keyPair.getPublic();

           System.out.println("Public key:"+Base64.encodeToString(rsaPrivateKey.getEncoded(),1));

           System.out.println("Private key:"+ Base64.encodeToString(rsaPrivateKey.getEncoded(),1));

 

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

            PKCS8EncodedKeySpecpkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());

            KeyFactorykeyFactory=KeyFactory.getInstance("RSA");

            PrivateKeyprivateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);

            Ciphercipher=Cipher.getInstance("RSA");

           cipher.init(Cipher.ENCRYPT_MODE, privateKey);

            byte[]result=cipher.doFinal(src.getBytes());

            System.out.println("私钥加密，公钥解密——加密:"+Base64.encodeToString(result,1));

 

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

            X509EncodedKeySpecx509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());

           keyFactory=KeyFactory.getInstance("RSA");

            PublicKeypublicKey=keyFactory.generatePublic(x509EncodedKeySpec);

           cipher=Cipher.getInstance("RSA");

           cipher.init(Cipher.DECRYPT_MODE,publicKey);

           result=cipher.doFinal(result);

            System.out.println(newString(result));

 

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

            x509EncodedKeySpec=newX509EncodedKeySpec(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=newPKCS8EncodedKeySpec(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();

        }

    }

}