`

Java中常用的加密方法(JDK)

java 
阅读更多

 

转载自 ---- http://www.iteye.com/topic/1122076

 

 

加密，是以某种特殊的算法改变原有的信息数据，使得未授权的用户即使获得了已加密的信息，但因不知解密的方法，仍然无法了解信息的内容。大体上分为双向加密 和单向加密 ，而双向加密又分为对称加密 和非对称加密 (有些资料将加密直接分为对称加密和非对称加密)。

双向加密大体意思就是明文加密后形成密文，可以通过算法还原成明文。而单向加密只是对信息进行了摘要计算，不能通过算法生成明文，单向加密从严格意思上说不能算是加密的一种，应该算是摘要算法吧。具体区分可以参考：
(本人解释不清呢 …… )
http://security.group.iteye.com/group/wiki/1710-one-way-encryption-algorithm
一、双向加密
(一)、对称加密
采用单钥密码系统的加密方法，同一个密钥可以同时用作信息的加密和解密，这种加密方法称为对称加密，也称为单密钥加密。
需要对加密和解密使用相同密钥的加密算法。由于其速度，对称性加密通常在消息发送方需要加密大量数据时使用。对称性加密也称为密钥加密。
所谓对称，就是采用这种加密方法的双方使用方式用同样的密钥进行加密和解密。密钥是控制加密及解密过程的指令。

算法是一组规则，规定如何进行加密和解密。因此对称式加密本身不是安全的。 　　
常用的对称加密有：DES、IDEA、RC2、RC4、SKIPJACK、RC5、AES算法等

对称加密一般java类中中定义成员

Java代码  收藏代码
  1. //KeyGenerator 提供对称密钥生成器的功能，支持各种算法   
  2. private  KeyGenerator keygen;  
  3. //SecretKey 负责保存对称密钥   
  4. private  SecretKey deskey;  
  5. //Cipher负责完成加密或解密工作   
  6. private  Cipher c;  
  7. //该字节数组负责保存加密的结果   
  8. private   byte [] cipherByte;  


在构造函数中初始化

Java代码  收藏代码
  1. Security.addProvider( new  com.sun.crypto.provider.SunJCE());  
  2. //实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)   
  3. keygen = KeyGenerator.getInstance("DES" ); //   
  4. //生成密钥   
  5. deskey = keygen.generateKey();  
  6. //生成Cipher对象,指定其支持的DES算法   
  7. c = Cipher.getInstance("DES" );  



1. DES 算法为密码体制中的对称密码体制，又被成为美国数据加密标准，是1972年美国IBM公司研制的 对称密码体制加密算法。 明文按64位进行分组, 密钥长64位，密钥事实上是56位参与DES运算（第8、16、24、32、40、48、56、64位是校验位， 使得每个密钥都有奇数个1）分组后的明文组和56位的密钥按位替代或交换的方法形成密文组的加密方法。

Java代码  收藏代码
  1. import  java.security.InvalidKeyException;  
  2. import  java.security.NoSuchAlgorithmException;  
  3. import  java.security.Security;  
  4.   
  5. import  javax.crypto.BadPaddingException;  
  6. import  javax.crypto.Cipher;  
  7. import  javax.crypto.IllegalBlockSizeException;  
  8. import  javax.crypto.KeyGenerator;  
  9. import  javax.crypto.NoSuchPaddingException;  
  10. import  javax.crypto.SecretKey;  
  11.   
  12. public   class  EncrypDES {  
  13.       
  14.     //KeyGenerator 提供对称密钥生成器的功能，支持各种算法   
  15.     private  KeyGenerator keygen;  
  16.     //SecretKey 负责保存对称密钥   
  17.     private  SecretKey deskey;  
  18.     //Cipher负责完成加密或解密工作   
  19.     private  Cipher c;  
  20.     //该字节数组负责保存加密的结果   
  21.     private   byte [] cipherByte;  
  22.       
  23.     public  EncrypDES()  throws  NoSuchAlgorithmException, NoSuchPaddingException{  
  24.         Security.addProvider(new  com.sun.crypto.provider.SunJCE());  
  25.         //实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)   
  26.         keygen = KeyGenerator.getInstance("DES" );  
  27.         //生成密钥   
  28.         deskey = keygen.generateKey();  
  29.         //生成Cipher对象,指定其支持的DES算法   
  30.         c = Cipher.getInstance("DES" );  
  31.     }  
  32.       
  33.     /**  
  34.      * 对字符串加密  
  35.      *   
  36.      * @param str  
  37.      * @return  
  38.      * @throws InvalidKeyException  
  39.      * @throws IllegalBlockSizeException  
  40.      * @throws BadPaddingException  
  41.      */   
  42.     public   byte [] Encrytor(String str)  throws  InvalidKeyException,  
  43.             IllegalBlockSizeException, BadPaddingException {  
  44.         // 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式   
  45.         c.init(Cipher.ENCRYPT_MODE, deskey);  
  46.         byte [] src = str.getBytes();  
  47.         // 加密，结果保存进cipherByte   
  48.         cipherByte = c.doFinal(src);  
  49.         return  cipherByte;  
  50.     }  
  51.   
  52.     /**  
  53.      * 对字符串解密  
  54.      *   
  55.      * @param buff  
  56.      * @return  
  57.      * @throws InvalidKeyException  
  58.      * @throws IllegalBlockSizeException  
  59.      * @throws BadPaddingException  
  60.      */   
  61.     public   byte [] Decryptor( byte [] buff)  throws  InvalidKeyException,  
  62.             IllegalBlockSizeException, BadPaddingException {  
  63.         // 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式   
  64.         c.init(Cipher.DECRYPT_MODE, deskey);  
  65.         cipherByte = c.doFinal(buff);  
  66.         return  cipherByte;  
  67.     }  
  68.   
  69.     /**  
  70.      * @param args  
  71.      * @throws NoSuchPaddingException   
  72.      * @throws NoSuchAlgorithmException   
  73.      * @throws BadPaddingException   
  74.      * @throws IllegalBlockSizeException   
  75.      * @throws InvalidKeyException   
  76.      */   
  77.     public   static   void  main(String[] args)  throws  Exception {  
  78.         EncrypDES de1 = new  EncrypDES();  
  79.         String msg ="郭XX-搞笑相声全集" ;  
  80.         byte [] encontent = de1.Encrytor(msg);  
  81.         byte [] decontent = de1.Decryptor(encontent);  
  82.         System.out.println("明文是:"  + msg);  
  83.         System.out.println("加密后:"  +  new  String(encontent));  
  84.         System.out.println("解密后:"  +  new  String(decontent));  
  85.     }  
  86.   
  87. }  



2. 3DES 又称Triple DES，是DES加密算法的一种模式，它使用3条56位的密钥对3DES
数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法，并于1981年被ANSI组织规范为ANSI X.3.92。DES使用56位密钥和密码块的方法，而在密码块的方法中，文本被分成64位大小的文本块然后再进行加密。比起最初的DES，3DES更为 安全。 　　
3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法，其具体实现如下：
设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，P代表明文，C代表密文，
这样， 　　
3DES加密过程为：C=Ek3(Dk2(Ek1(P)))
3DES解密过程为：P=Dk1((EK2(Dk3(C)))

Java代码  收藏代码
  1. import  java.security.InvalidKeyException;  
  2. import  java.security.NoSuchAlgorithmException;  
  3. import  java.security.Security;  
  4.   
  5. import  javax.crypto.BadPaddingException;  
  6. import  javax.crypto.Cipher;  
  7. import  javax.crypto.IllegalBlockSizeException;  
  8. import  javax.crypto.KeyGenerator;  
  9. import  javax.crypto.NoSuchPaddingException;  
  10. import  javax.crypto.SecretKey;  
  11.   
  12. public   class  EncrypDES3 {  
  13.   
  14.     // KeyGenerator 提供对称密钥生成器的功能，支持各种算法   
  15.     private  KeyGenerator keygen;  
  16.     // SecretKey 负责保存对称密钥   
  17.     private  SecretKey deskey;  
  18.     // Cipher负责完成加密或解密工作   
  19.     private  Cipher c;  
  20.     // 该字节数组负责保存加密的结果   
  21.     private   byte [] cipherByte;  
  22.   
  23.     public  EncrypDES3()  throws  NoSuchAlgorithmException, NoSuchPaddingException {  
  24.         Security.addProvider(new  com.sun.crypto.provider.SunJCE());  
  25.         // 实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)   
  26.         keygen = KeyGenerator.getInstance("DESede" );  
  27.         // 生成密钥   
  28.         deskey = keygen.generateKey();  
  29.         // 生成Cipher对象,指定其支持的DES算法   
  30.         c = Cipher.getInstance("DESede" );  
  31.     }  
  32.   
  33.     /**  
  34.      * 对字符串加密  
  35.      *   
  36.      * @param str  
  37.      * @return  
  38.      * @throws InvalidKeyException  
  39.      * @throws IllegalBlockSizeException  
  40.      * @throws BadPaddingException  
  41.      */   
  42.     public   byte [] Encrytor(String str)  throws  InvalidKeyException,  
  43.             IllegalBlockSizeException, BadPaddingException {  
  44.         // 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式   
  45.         c.init(Cipher.ENCRYPT_MODE, deskey);  
  46.         byte [] src = str.getBytes();  
  47.         // 加密，结果保存进cipherByte   
  48.         cipherByte = c.doFinal(src);  
  49.         return  cipherByte;  
  50.     }  
  51.   
  52.     /**  
  53.      * 对字符串解密  
  54.      *   
  55.      * @param buff  
  56.      * @return  
  57.      * @throws InvalidKeyException  
  58.      * @throws IllegalBlockSizeException  
  59.      * @throws BadPaddingException  
  60.      */   
  61.     public   byte [] Decryptor( byte [] buff)  throws  InvalidKeyException,  
  62.             IllegalBlockSizeException, BadPaddingException {  
  63.         // 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式   
  64.         c.init(Cipher.DECRYPT_MODE, deskey);  
  65.         cipherByte = c.doFinal(buff);  
  66.         return  cipherByte;  
  67.     }  
  68.   
  69.     /**  
  70.      * @param args  
  71.      * @throws NoSuchPaddingException   
  72.      * @throws NoSuchAlgorithmException   
  73.      * @throws BadPaddingException   
  74.      * @throws IllegalBlockSizeException   
  75.      * @throws InvalidKeyException   
  76.      */   
  77.     public   static   void  main(String[] args)  throws  Exception {  
  78.         EncrypDES3 des = new  EncrypDES3();  
  79.         String msg ="郭XX-搞笑相声全集" ;  
  80.         byte [] encontent = des.Encrytor(msg);  
  81.         byte [] decontent = des.Decryptor(encontent);  
  82.         System.out.println("明文是:"  + msg);  
  83.         System.out.println("加密后:"  +  new  String(encontent));  
  84.         System.out.println("解密后:"  +  new  String(decontent));  
  85.   
  86.     }  
  87.   
  88. }  



3. AES 密码学中的高级加密标准（Advanced Encryption Standard，AES），又称  高级加密标准
Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的 甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。 　　该算法为比利时密码学家Joan Daemen和Vincent Rijmen所设计，结合两位作者的名字，以Rijndael之命名之，投稿高级加密标准的甄选流程。（Rijdael的发音近于 "Rhinedoll"。）

Java代码  收藏代码
  1. import  java.security.InvalidKeyException;  
  2. import  java.security.NoSuchAlgorithmException;  
  3. import  java.security.Security;  
  4.   
  5. import  javax.crypto.BadPaddingException;  
  6. import  javax.crypto.Cipher;  
  7. import  javax.crypto.IllegalBlockSizeException;  
  8. import  javax.crypto.KeyGenerator;  
  9. import  javax.crypto.NoSuchPaddingException;  
  10. import  javax.crypto.SecretKey;  
  11.   
  12. public   class  EncrypAES {  
  13.       
  14.     //KeyGenerator 提供对称密钥生成器的功能，支持各种算法   
  15.     private  KeyGenerator keygen;  
  16.     //SecretKey 负责保存对称密钥   
  17.     private  SecretKey deskey;  
  18.     //Cipher负责完成加密或解密工作   
  19.     private  Cipher c;  
  20.     //该字节数组负责保存加密的结果   
  21.     private   byte [] cipherByte;  
  22.       
  23.     public  EncrypAES()  throws  NoSuchAlgorithmException, NoSuchPaddingException{  
  24.         Security.addProvider(new  com.sun.crypto.provider.SunJCE());  
  25.         //实例化支持DES算法的密钥生成器(算法名称命名需按规定，否则抛出异常)   
  26.         keygen = KeyGenerator.getInstance("AES" );  
  27.         //生成密钥   
  28.         deskey = keygen.generateKey();  
  29.         //生成Cipher对象,指定其支持的DES算法   
  30.         c = Cipher.getInstance("AES" );  
  31.     }  
  32.       
  33.     /**  
  34.      * 对字符串加密  
  35.      *   
  36.      * @param str  
  37.      * @return  
  38.      * @throws InvalidKeyException  
  39.      * @throws IllegalBlockSizeException  
  40.      * @throws BadPaddingException  
  41.      */   
  42.     public   byte [] Encrytor(String str)  throws  InvalidKeyException,  
  43.             IllegalBlockSizeException, BadPaddingException {  
  44.         // 根据密钥，对Cipher对象进行初始化，ENCRYPT_MODE表示加密模式   
  45.         c.init(Cipher.ENCRYPT_MODE, deskey);  
  46.         byte [] src = str.getBytes();  
  47.         // 加密，结果保存进cipherByte   
  48.         cipherByte = c.doFinal(src);  
  49.         return  cipherByte;  
  50.     }  
  51.   
  52.     /**  
  53.      * 对字符串解密  
  54.      *   
  55.      * @param buff  
  56.      * @return  
  57.      * @throws InvalidKeyException  
  58.      * @throws IllegalBlockSizeException  
  59.      * @throws BadPaddingException  
  60.      */   
  61.     public   byte [] Decryptor( byte [] buff)  throws  InvalidKeyException,  
  62.             IllegalBlockSizeException, BadPaddingException {  
  63.         // 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式   
  64.         c.init(Cipher.DECRYPT_MODE, deskey);  
  65.         cipherByte = c.doFinal(buff);  
  66.         return  cipherByte;  
  67.     }  
  68.   
  69.     /**  
  70.      * @param args  
  71.      * @throws NoSuchPaddingException   
  72.      * @throws NoSuchAlgorithmException   
  73.      * @throws BadPaddingException   
  74.      * @throws IllegalBlockSizeException   
  75.      * @throws InvalidKeyException   
  76.      */   
  77.     public   static   void  main(String[] args)  throws  Exception {  
  78.         EncrypAES de1 = new  EncrypAES();  
  79.         String msg ="郭XX-搞笑相声全集" ;  
  80.         byte [] encontent = de1.Encrytor(msg);  
  81.         byte [] decontent = de1.Decryptor(encontent);  
  82.         System.out.println("明文是:"  + msg);  
  83.         System.out.println("加密后:"  +  new  String(encontent));  
  84.         System.out.println("解密后:"  +  new  String(decontent));  
  85.     }  
  86.   
  87. }  



(二)、非对称加密
1976年，美国学者Dime和Henman为解决信息公开传送和密钥管理问题，提出一种新的密钥交换协议，允许在不安全的媒体上的通讯双方交换 信息，安全地达成一致的密钥，这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥（publickey）和私有密钥
（privatekey）。公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

1. RSA 公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够 抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对 其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

Java代码  收藏代码
  1. import  java.security.InvalidKeyException;  
  2. import  java.security.KeyPair;  
  3. import  java.security.KeyPairGenerator;  
  4. import  java.security.NoSuchAlgorithmException;  
  5. import  java.security.interfaces.RSAPrivateKey;  
  6. import  java.security.interfaces.RSAPublicKey;  
  7.   
  8. import  javax.crypto.BadPaddingException;  
  9. import  javax.crypto.Cipher;  
  10. import  javax.crypto.IllegalBlockSizeException;  
  11. import  javax.crypto.NoSuchPaddingException;  
  12.   
  13. public   class  EncrypRSA {  
  14.       
  15.     /**  
  16.      * 加密  
  17.      * @param publicKey  
  18.      * @param srcBytes  
  19.      * @return  
  20.      * @throws NoSuchAlgorithmException  
  21.      * @throws NoSuchPaddingException  
  22.      * @throws InvalidKeyException  
  23.      * @throws IllegalBlockSizeException  
  24.      * @throws BadPaddingException  
  25.      */   
  26.     protected   byte [] encrypt(RSAPublicKey publicKey, byte [] srcBytes)  throws  NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{  
  27.         if (publicKey!= null ){  
  28.             //Cipher负责完成加密或解密工作，基于RSA   
  29.             Cipher cipher = Cipher.getInstance("RSA" );  
  30.             //根据公钥，对Cipher对象进行初始化   
  31.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
  32.             byte [] resultBytes = cipher.doFinal(srcBytes);  
  33.             return  resultBytes;  
  34.         }  
  35.         return   null ;  
  36.     }  
  37.       
  38.     /**  
  39.      * 解密   
  40.      * @param privateKey  
  41.      * @param srcBytes  
  42.      * @return  
  43.      * @throws NoSuchAlgorithmException  
  44.      * @throws NoSuchPaddingException  
  45.      * @throws InvalidKeyException  
  46.      * @throws IllegalBlockSizeException  
  47.      * @throws BadPaddingException  
  48.      */   
  49.     protected   byte [] decrypt(RSAPrivateKey privateKey, byte [] srcBytes)  throws  NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{  
  50.         if (privateKey!= null ){  
  51.             //Cipher负责完成加密或解密工作，基于RSA   
  52.             Cipher cipher = Cipher.getInstance("RSA" );  
  53.             //根据公钥，对Cipher对象进行初始化   
  54.             cipher.init(Cipher.DECRYPT_MODE, privateKey);  
  55.             byte [] resultBytes = cipher.doFinal(srcBytes);  
  56.             return  resultBytes;  
  57.         }  
  58.         return   null ;  
  59.     }  
  60.   
  61.     /**  
  62.      * @param args  
  63.      * @throws NoSuchAlgorithmException   
  64.      * @throws BadPaddingException   
  65.      * @throws IllegalBlockSizeException   
  66.      * @throws NoSuchPaddingException   
  67.      * @throws InvalidKeyException   
  68.      */   
  69.     public   static   void  main(String[] args)  throws  NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {  
  70.         EncrypRSA rsa = new  EncrypRSA();  
  71.         String msg = "郭XX-精品相声" ;  
  72.         //KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象   
  73.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA" );  
  74.         //初始化密钥对生成器，密钥大小为1024位   
  75.         keyPairGen.initialize(1024 );  
  76.         //生成一个密钥对，保存在keyPair中   
  77.         KeyPair keyPair = keyPairGen.generateKeyPair();  
  78.         //得到私钥   
  79.         RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();               
  80.         //得到公钥   
  81.         RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();  
  82.           
  83.         //用公钥加密   
  84.         byte [] srcBytes = msg.getBytes();  
  85.         byte [] resultBytes = rsa.encrypt(publicKey, srcBytes);  
  86.           
  87.         //用私钥解密   
  88.         byte [] decBytes = rsa.decrypt(privateKey, resultBytes);  
  89.           
  90.         System.out.println("明文是:"  + msg);  
  91.         System.out.println("加密后是:"  +  new  String(resultBytes));  
  92.         System.out.println("解密后是:"  +  new  String(decBytes));  
  93.     }  
  94.   
  95. }  



2. DSA
Digital Signature Algorithm (DSA)是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。(感觉有点复杂，没有附代码)
详见http://63938525.iteye.com/blog/1051565

(三)、题外话 MySQL加密解密函数
MySQL有两个函数来支持这种类型的加密，分别叫做ENCODE()和DECODE()。
下面是一个简单的实例：

Mysql代码  收藏代码
  1. mysql> INSERT INTO users (username,password) VALUES ( 'joe' ,ENCODE( 'guessme' , 'abr' ));  
  2.   
  3. Query OK， 1  row affected （ 0.14  sec）  


其中，Joe的密码是guessme，它通过密钥abracadabra被加密。要注意的是，加密完的结果是一个二进制字符串，如下所示：

提示：虽然ENCODE()和DECODE()这两个函数能够满足大多数的要求，但是有的时候您希望使用强度更高的加密手段。在这种情况下，您可以使用AES_ENCRYPT()和AES_DECRYPT()函数，它们的工作方式是相同的，但是加密强度更高。


单向加密与双向加密不同，一旦数据被加密就没有办法颠倒这一过程。因此密码的验证包括对用户输入内容的重新加密，并将它与保存的密文进行比对，看 是否匹配。一种简单的单向加密方式是MD5校验码。MySQL的MD5（）函数会为您的数据创建一个“指纹”并将它保存起来，供验证测试使用。下面就是如 何使用它的一个简单例子：

Mysql代码  收藏代码
  1. mysql> INSERT INTO users (username,password) VALUES ( 'joe' ,MD5( 'guessme' ));  
  2.   
  3. Query OK， 1  row affected （ 0.00  sec）  




或者，您考虑一下使用ENCRYPT（）函数，它使用系统底层的crypt（）系统调用来完成加密。这个函数有两个参数：一个是要被加密的字符 串，另一个是双（或者多）字符的“salt”。它然后会用salt加密字符串；这个salt然后可以被用来再次加密用户输入的内容，并将它与先前加密的字 符串进行比对。下面一个例子说明了如何使用它：

Mysql代码  收藏代码
  1. mysql> INSERT INTO users (username,password) VALUES( 'joe' ， ENCRYPT( 'guessme' , 'ab' ));  
  2.   
  3. Query OK， 1  row affected （ 0.00  sec）  




提示：ENCRYPT()只能用在UNIX、LINIX系统上，因为它需要用到底层的crypt()库。

二、单向加密(信息摘要)
Java一般需要获取对象MessageDigest来实现单项加密(信息摘要)。
1. MD5 即Message-Digest Algorithm 5（信息-摘要算法 5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。将数据（如汉字）运算为 另一固定长度值，是杂凑算法的基础原理，MD5的前身有MD2、MD3和MD4。MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被"压缩"成 一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。
除了MD5以外，其中比较有名的还有sha-1、RIPEMD以及Haval等

Java代码  收藏代码
  1. import  java.security.MessageDigest;  
  2. import  java.security.NoSuchAlgorithmException;  
  3.   
  4. public   class  EncrypMD5 {  
  5.       
  6.     public   byte [] eccrypt(String info)  throws  NoSuchAlgorithmException{  
  7.         //根据MD5算法生成MessageDigest对象   
  8.         MessageDigest md5 = MessageDigest.getInstance("MD5" );  
  9.         byte [] srcBytes = info.getBytes();  
  10.         //使用srcBytes更新摘要   
  11.         md5.update(srcBytes);  
  12.         //完成哈希计算，得到result   
  13.         byte [] resultBytes = md5.digest();  
  14.         return  resultBytes;  
  15.     }  
  16.       
  17.       
  18.     public   static   void  main(String args[])  throws  NoSuchAlgorithmException{  
  19.         String msg = "郭XX-精品相声技术" ;  
  20.         EncrypMD5 md5 = new  EncrypMD5();  
  21.         byte [] resultBytes = md5.eccrypt(msg);  
  22.           
  23.         System.out.println("密文是："  +  new  String(resultBytes));  
  24.         System.out.println("明文是："  + msg);  
  25.     }  
  26.   
  27. }  



2. SHA 是一种数据加密算法，该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用。该算法的思想是接收一段明 文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的 输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说时对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明 文的数字签名。

Java代码  收藏代码
  1. import  java.security.MessageDigest;  
  2. import  java.security.NoSuchAlgorithmException;  
  3.   
  4. public   class  EncrypSHA {  
  5.       
  6.     public   byte [] eccrypt(String info)  throws  NoSuchAlgorithmException{  
  7.         MessageDigest md5 = MessageDigest.getInstance("SHA" );  
  8.         byte [] srcBytes = info.getBytes();  
  9.         //使用srcBytes更新摘要   
  10.         md5.update(srcBytes);  
  11.         //完成哈希计算，得到result   
  12.         byte [] resultBytes = md5.digest();  
  13.         return  resultBytes;  
  14.     }  
  15.   
  16.     /**  
  17.      * @param args  
  18.      * @throws NoSuchAlgorithmException   
  19.      */   
  20.     public   static   void  main(String[] args)  throws  NoSuchAlgorithmException {  
  21.         String msg = "郭XX-精品相声技术" ;  
  22.         EncrypSHA sha = new  EncrypSHA();  
  23.         byte [] resultBytes = sha.eccrypt(msg);  
  24.         System.out.println("明文是："  + msg);  
  25.         System.out.println("密文是："  +  new  String(resultBytes));  
  26.           
  27.     }  
  28.   
  29. }  



附件中是以上几种的源代码，附带额外的两种使用方式。

增加一种关于文件的哈希算法源代码：

Java代码  收藏代码
  1. import  java.io.FileInputStream;  
  2. import  java.io.InputStream;  
  3. import  java.security.MessageDigest;  
  4.   
  5. public   class  FileHashUtil {  
  6.   
  7.     public   static   final   char [] hexChar = {   
  8.             '0' ,  '1' ,  '2' ,  '3' ,  '4' ,  '5' ,  '6' ,  '7' ,  '8' ,  '9' ,  'a' ,  'b' ,  'c' ,  'd' ,  'e' ,  'f'  };  
  9.     public   static   final  String[] hashTypes =  new  String[] {  "MD2" ,  "MD5" ,  "SHA1" ,  "SHA-256" ,  "SHA-384" ,  "SHA-512"  };  
  10.       
  11.     public   void  MD5File(String fileName)  throws  Exception{  
  12.         //String fileName = args[0];   
  13.         System.out.println("需要获取hash的文件为：　"  + fileName);  
  14.         java.util.List<MessageDigest> mds = new  java.util.ArrayList<MessageDigest>();  
  15.         for  (String hashType : hashTypes) {  
  16.             MessageDigest md = MessageDigest.getInstance(hashType);  
  17.             mds.add(md);  
  18.         }  
  19.         InputStream fis = null ;  
  20.         try  {  
  21.             fis = new  FileInputStream(fileName);  
  22.             byte [] buffer =  new   byte [ 1024 ];  
  23.             int  numRead =  0 ;  
  24.             while  ((numRead = fis.read(buffer)) >  0 ) {  
  25.                 for  (MessageDigest md : mds) {  
  26.                     md.update(buffer, 0 , numRead);  
  27.                 }  
  28.             }  
  29.         } catch  (Exception ex) {  
  30.             ex.printStackTrace();  
  31.         } finally  {  
  32.             if  (fis !=  null ) {  
  33.                 fis.close();  
  34.             }  
  35.         }  
  36.         for  (MessageDigest md : mds) {  
  37.             System.out.println(md.getAlgorithm() + " == "  + toHexString(md.digest()));  
  38.         }  
  39.     }  
  40.       
  41.   
  42.     public   static   void  main(String[] args)  throws  Exception {  
  43.         String[] fileName = new  String[] { "D:/hapfish/ShellFolder.java" , "D:/hapfish/ShellFolder - 副本.java" ,  
  44.                   "E:/ShellFolder - 副本.java" , "E:/ShellFolder.txt" , "D:/hapfish/ShellFolder.jpg" ,  
  45.                   "E:/ShellFolder增加字符.txt" , "D:/hapfish/birosoft.jar" };  
  46.         FileHashUtil files  = new  FileHashUtil();  
  47.         for ( int  i= 0 ;i<fileName.length;i++){  
  48.             files.MD5File(fileName[i]);  
  49.         }   
  50.           
  51.           
  52.     }  
  53.   
  54.     public   static  String toHexString( byte [] b) {  
  55.         StringBuilder sb = new  StringBuilder(b.length *  2 );  
  56.         for  ( int  i =  0 ; i < b.length; i++) {  
  57.             sb.append(hexChar[(b[i] & 0xf0 ) >>>  4 ]);  
  58.             sb.append(hexChar[b[i] & 0x0f ]);  
  59.         }  
  60.         return  sb.toString();  
  61.     }  
  62.   
  63. }  



运行说明

说明代码  收藏代码
  1. "D:/hapfish/ShellFolder.java" ,  
  2. "D:/hapfish/ShellFolder - 副本.java" ,  
  3. "E:/ShellFolder - 副本.java" ,  
  4. "E:/ShellFolder.txt" ,  
  5. "D:/hapfish/ShellFolder.jpg" ,  
  6. 以上五个文件是同一文件经过复制、改扩展名的，最后计算哈希结果是一致的。  
  7.   
  8. "E:/ShellFolder增加字符.txt"  增加了几个字符串，就不一样了  
  9.   
  10. "D:/hapfish/birosoft.jar"  完全不相关的另外一个文件  



运行结果：

Java代码  收藏代码
  1. 需要获取hash的文件为：　D:/hapfish/ShellFolder.java  
  2. MD2 == 3a755a99c5e407005cd45ebd856b4649  
  3. MD5 == 5d08d440fa911d1e418c69a90b83cd86  
  4. SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63  
  5. SHA-256  == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99  
  6. SHA-384  == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6  
  7. SHA-512  == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458  
  8. 需要获取hash的文件为：　D:/hapfish/ShellFolder - 副本.java  
  9. MD2 == 3a755a99c5e407005cd45ebd856b4649  
  10. MD5 == 5d08d440fa911d1e418c69a90b83cd86  
  11. SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63  
  12. SHA-256  == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99  
  13. SHA-384  == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6  
  14. SHA-512  == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458  
  15. 需要获取hash的文件为：　E:/ShellFolder - 副本.java  
  16. MD2 == 3a755a99c5e407005cd45ebd856b4649  
  17. MD5 == 5d08d440fa911d1e418c69a90b83cd86  
  18. SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63  
  19. SHA-256  == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99  
  20. SHA-384  == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6  
  21. SHA-512  == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458  
  22. 需要获取hash的文件为：　E:/ShellFolder.txt  
  23. MD2 == 3a755a99c5e407005cd45ebd856b4649  
  24. MD5 == 5d08d440fa911d1e418c69a90b83cd86  
  25. SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63  
  26. SHA-256  == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99  
  27. SHA-384  == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6  
  28. SHA-512  == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458  
  29. 需要获取hash的文件为：　D:/hapfish/ShellFolder.jpg  
  30. MD2 == 3a755a99c5e407005cd45ebd856b4649  
  31. MD5 == 5d08d440fa911d1e418c69a90b83cd86  
  32. SHA1 == 522c8c4f4ff1dd669e251c2ab854c3033a51ca63  
  33. SHA-256  == d1feb0c73c10a759e88bd240cb9d56d0598b4ff83a0704c6679f7ba12f6c4d99  
  34. SHA-384  == 8f8c9da4cd7241c58af3c52b49199033f2dcf3d67f421753999f87511618d9ea2d738e8c16b9b68a7572d06108ff10f6  
  35. SHA-512  == 4711579daee3ddacbaea189310348956cb43bcaaf0099f3be047b06f16c1a20a6b71ee3a4ee018128d647e9f2ef0d644747672238e49a8da3d0cd26dfe597458  
  36. 需要获取hash的文件为：　E:/ShellFolder增加字符.txt  
  37. MD2 == f2717c24c6c0e110457bd17221c9ca6c  
  38. MD5 == c49e353a7c4c26bd7ccb5e90917c230f  
  39. SHA1 == 477c8a9e465bfaa4be42d35c032a17f7e6b42b97  
  40. SHA-256  == 9fa18adaf242ebcdc6563922d84c2a163c82e1a24db2eb2b73978ed1f354a8a3  
  41. SHA-384  == 4eee8f8e6d64d21c15dc01fa049f4d12a3b8e1d94d87763fe0bea75ab5ea8432fa8251289ece45ee39fe3d36b3c3020c  
  42. SHA-512  == e852ec0ff77250be497389d2f5a1818c18bb66106b9905c4ee26fe0d256eb3b77e0ce9a28a84e4b67e4332ba37ec3aa7518148e3a682318c0fc34c391f45c201  
  43. 需要获取hash的文件为：　D:/hapfish/birosoft.jar  
  44. MD2 == 38c5e1404718916dec59c33cafc909b3  
  45. MD5 == dc3e2cc4fb3949cf3660e0f5f8c3fba3  
  46. SHA1 == cde3dc25498afc5a563af0bb0eb54dc45f71bb28  
  47. SHA-256  == adf6a961c70c6ea677dff066fc5d896fb0beb4dd442ca0eb619ae1d1b04291e5  
  48. SHA-384  == fe7c6b754893c53ebd82bb53703fb5cc32115c9a38f98072f73def90729b271ee3c5c78e258bd9ff5ee5476193c2178b  
  49. SHA-512  == a15376f327256a6e049dfbdc5c2ad3a98bffccc6fa92ee01ff53db6b04471ca0f45ca28f76ff4a6911b57825afa046671299141f2499d71f1dac618c92385491  



最后，把运行结果贴出来有点占空间，主要为了说明表述自己的猜想。一般来说同一哈希算法对同一文件(镜像、扩展名被修改)所产生的结果应该是一致的。

因此有个猜想，在baidu文库、腾讯的群共享上传时，先会判断是否有相同文件，从某种可能上来说也采用了对文件的哈希算法，毕竟从本地运算一个哈希算法后获得的数值要比把整个文件传过去比较实惠得多。而且字符串的比较也是很方便的。

对于某一种哈希算法，存在一种可能：就是两个不同的文件，计算出来的哈希值可能是一样的。当然为了保险，可以用两种甚至更多的哈希算法，只有在每种算法获得的哈希值都相同时，才能判断是同一个文件。
如果我们也对用户上传的文件进行哈希计算的话，就可以节省资源，同样的文件按理说可以减少上传次数……

分享到：
| GitHub 与社会化编程
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JCT - java加密解密工具包.zip_Java加密_java 加密_jct java_加密 解密_加密工具

    10. **兼容性**：考虑到Java的跨平台特性，JCT工具包应该能在各种Java运行环境中正常工作，包括JRE（Java Runtime Environment）和JDK（Java Development Kit）。 总的来说，JCT是一个全面的Java加密解密解决方案，...

    Java jdk api 1.8_google.CHM JDK API 1.8谷歌翻译中文版在线参考手册

    《Java JDK API 1.8谷歌翻译中文版在线参考手册》是Java开发者不可或缺的重要参考资料，它详尽地列出了Java开发工具包（JDK）1.8版本中的各种类库、接口、方法和异常，为程序员提供了清晰的API文档。这份手册通过...

    Java实现文件加密工具 附源码

    Java实现的文件加密工具是一种基于源码的程序，它能够在JDK1.5及以上的环境中运行。这个工具的独特之处在于其灵活性，允许用户使用任何字符作为加密密码，为数据安全提供了广泛的可能性。此外，该工具还支持使用一个...

    jdk常用版本以及最新版本

    在Java技术的发展历程中，JDK的不同版本扮演了关键角色，为开发者提供了新的特性和改进，以适应不断变化的技术需求。 标题提到的"jdk常用版本以及最新版本"，主要涉及以下几个知识点： 1. **JDK1.7**：也称为Java ...

    java加密算法实现

    本文将详细介绍Java中常见的加密算法的实现，以及如何在JDK 1.8环境下进行操作。 1. **对称加密算法** 对称加密是最基础的加密方式，使用相同的密钥进行加密和解密。Java中提供了`javax.crypto`包来支持此类算法，...

    Java字节码加密工具

    Java字节码加密工具是一种用于保护Java应用程序源代码安全的工具。在软件开发过程中，源代码是开发者的心血结晶，包含了许多重要的商业逻辑和技术细节。然而，Java的字节码（.class文件）虽然相对于源代码（.java...

    java实现非对称加密

    在 Java 中，可以使用 RSA 算法实现非对称加密。 RSA 算法是最常用的非对称加密算法之一。它的安全性取决于密钥的长度和安全性。 Java 中的 RSA 加密可以分为以下步骤： 1. 生成公钥和私钥：使用 KeyPairGenerator...

    IntelliJIEDA+JDK1.8 常用密码学JAVA软算工程

    这个项目中的`JCEProject`可能是一个包含所有这些算法实现的Java项目，JCE（Java Cryptography Extension）是Java平台的扩展，用于支持更高级别的加密功能。开发者可以通过这个项目学习如何在Java中实现和使用这些...

    jdk 1.8.0_91.rar

    Java JDK 1.8.0_91 是...总之，Java JDK 1.8.0_91是一个重要的版本，它的便捷性、稳定性和性能优化使得它成为Java开发者常用的开发工具之一。无论是初学者还是经验丰富的程序员，都能从中受益，实现高效的Java编程。

    Java JDK1.7对字符串的BASE64编码解码方法

    在Java开发中，BASE64编码解码是一种常用的字符串处理方式，特别是在网络数据传输和加密存储中。在Java JDK1.7中，字符串的BASE64编码解码可以使用sun.misc包下的BASE64Encoder和BASE64Decoder类来实现。 首先， ...

    AES加密时抛出java.security.InvalidKeyException: Illegal key size or default parameter

    当在Java环境中使用AES加密时遇到 `java.security.InvalidKeyException: Illegal key size or default parameter` 这个异常，通常意味着密钥的长度超过了Java安全策略所允许的最大值。具体来说： - **非法密钥大小...

    java17.0.4.1帮助文档

    帮助文档可能包含了关于如何正确配置和使用安全策略、证书和密钥库的信息，以及关于Java加密API（如`java.security.KeyStore` 和 `java.security.cert.Certificate`）的使用说明。 此外，对于新特性或改进，比如...

    jdk8 32位及64位安装包，2个独立安装包，不是一个。安装完系统内显示文件版本8.0.730.2

    jdk_8u73_windows_i586_8.0.730.2和jdk-8u73-windows-x64两个不同系统版本的安装包 jdk8 是一款非常好用的java开发类工具，这款软件中集成了超多全新的特性，且软件中还有着丰富的模板功能。软件中的各种功能也十分...

    bcprov-ext-jdk15on-1.54.jar、bcprov-jdk15on-1.54.jar和ssl-provider-jvm16-0.2.jar

    标题中的"bcprov-ext-jdk15on-1.54.jar"和"bcprov-jdk15on-1.54.jar"是Bouncy Castle提供的Java加密库，用于增强Java平台的安全性。Bouncy Castle是一个开源项目，提供强大的加密算法实现，包括SSL/TLS协议支持，...

    java版国密SM4算法

    CBC模式是一种常用的块密码工作模式，它通过前一个密文块与当前明文块异或后再进行加密，使得即使相同的明文在不同的密钥和初始向量下也会得到不同的密文，增强了安全性。而ECB模式是最简单的工作模式，每个明文块...

    Java实现的对称加密算法AES定义与用法详解

    "Java实现的对称加密算法AES定义与用法详解" 对称加密算法AES是当前使用最多的加密算法之一，其主要特点是高级的、安全的、快速的和灵活的。下面我们将详细介绍Java实现的对称加密算法AES的定义、特点、用法及使用...

    bcprov-jdk15to18-165

    总之，bcprov-jdk15to18-165是Bouncy Castle提供的一款针对Java 15至18的加密库，它扩展了Java的标准加密功能，为开发者提供了广泛的加密算法和协议支持，广泛应用于各种安全相关的Java项目中。

    Java_加密解密之对称加密算法DES

    Java 加密解密之对称加密算法 DES 是一种常用的对称加密算法，广泛应用于保护金融数据的安全中。它的全称是 Data Encryption Algorithm（DEA），最早由 IBM 开发，并曾拥有专利权，后来在 1983 年专利权到期，变为...

Magicbox
Global site tag (gtag.js) - Google Analytics