DES 加密算法

最新推荐文章于 2025-07-09 10:50:41 发布

HenryLee699

最新推荐文章于 2025-07-09 10:50:41 发布

阅读量981

点赞数

文章标签： DES 加密算法

在项目中，会经常用到数据的加密处理，对敏感的数据处理。我在项目中用到了记录用户名和密码的功能。在做远程登陆时使用。

DES 加密，现在还没有使用加密机。直接上代码了。

DES 加密接口

[java]view plain copy 
   
 package com.hkrt.des;  
   
 public interface Encrypt {  
     /** 
      * DES加密 
      * @param key 是十六进制 
      * @param src ASCII值 
      * @return ASCII 值 会有不可见字符 通常把加密后的数据转成十六进制 
      * @throws Exception 
      */  
     public byte[] DesEncryptByte2(String key, byte [] src)throws Exception;//  
     /** 
      * DES解密 
      * @param key 是十六进制 
      * @param src 是十六进制 
      * @return  
      * @throws Exception 
      */  
     public String DesDecrypt(String key, String src)throws Exception;//  
 }  

DES 加密接口实现

[java]view plain copy 
   
 package com.hkrt.des;  
   
 import javax.crypto.Cipher;  
 import javax.crypto.SecretKey;  
 import javax.crypto.spec.SecretKeySpec;  
   
   
 public class Des implements Encrypt {  
     private static final String DES = "DES"; // 定义 加密算法  
     private static final String CFB = "DES/ECB/NoPadding"; //   
   
     // DES解密  
     public String DesDecrypt(String key, String szSrc) throws Exception {  
         String str = "";  
   
         if (key.length() != 16) {  
             throw new Exception("DES密钥长度必须为十六进制的16字节");  
         }  
         byte[] srcBytes = DESdecryptMode(hexStr2ByteArr(key), hexStr2ByteArr(szSrc));  
           
         byte[] srcBytesEnd = srcBytes;  
         str = new String(srcBytesEnd);  
         return str;  
     }  
   
       
     // DES解密方法  
     public static byte[] DESdecryptMode(byte[] keybyte, byte[] src) {  
         try {  
             // 生成密钥  
             SecretKey deskey = new SecretKeySpec(keybyte, DES);  
   
             // 解密  
             Cipher c1 = Cipher.getInstance(CFB);  
             c1.init(Cipher.DECRYPT_MODE, deskey);  
             return c1.doFinal(src);  
         } catch (java.security.NoSuchAlgorithmException e1) {  
             e1.printStackTrace();  
         } catch (javax.crypto.NoSuchPaddingException e2) {  
             e2.printStackTrace();  
         } catch (java.lang.Exception e3) {  
             e3.printStackTrace();  
         }  
         return null;  
     }  
       
     //将十六进制字符串转换成原始字节数组  
     public static byte[] hexStr2ByteArr(String strIn) throws Exception {  
         System.out.println("---"+strIn);  
            byte[] arrB = strIn.getBytes();  
            int iLen = arrB.length;  
   
            byte[] arrOut = new byte[iLen / 2];  
            for (int i = 0; i < iLen; i = i + 2) {  
             String strTmp = new String(arrB, i, 2);  
             arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);  
            // System.out.println(arrOut[i/2]);  
            }  
            return arrOut;  
              
     }  
       
     // DES加密 返回byte[]  
     public byte[] DesEncryptByte2(String key, byte [] szSrc) throws Exception {  
         if(szSrc.length %8 != 0){  
             throw new Exception("数据体的长度必须为8的倍数");  
         }  
         if (key.length() != 16) {  
             throw new Exception("DES密钥长度必须为十六进制的16字节");  
         }  
         byte[] encoded = DESencryptMode(hexStr2ByteArr(key), szSrc);  
           
         return encoded;  
   
     }  
     // DES加密方法  
     public byte[] DESencryptMode(byte[] keybyte, byte[] src) {  
         try {  
   
             // 生成密钥  
             SecretKey deskey = new SecretKeySpec(keybyte, DES);  
               
   
             // 加密  
             Cipher c1 = Cipher.getInstance(CFB);  
             c1.init(Cipher.ENCRYPT_MODE, deskey);  
             return c1.doFinal(src);  
         } catch (java.security.NoSuchAlgorithmException e1) {  
             e1.printStackTrace();  
         } catch (javax.crypto.NoSuchPaddingException e2) {  
             e2.printStackTrace();  
         } catch (java.lang.Exception e3) {  
             e3.printStackTrace();  
         }  
         return null;  
     }  
       
   
       
       
 }  

DesUtil 工具类

[java]view plain copy 
   
 package com.hkrt.des;  
   
 import java.util.ArrayList;  
   
 public class DesUtil {  
     /** 右补null */  
     public static byte[] fillByte(byte[] bRecv) {  
         int iLen;  
         iLen = (bRecv.length) % 8;  
         byte[] bSend;  
         if (iLen != 0) {  
             iLen = 8 - iLen;  
             byte[] bSpace = new byte[iLen];  
             bSend = new byte[bRecv.length + iLen];  
             System.arraycopy(bRecv, 0, bSend, 0, bRecv.length);  
             for (int i = 0; i < iLen; i++) {  
                 // 不足位数补空格  
                 bSpace[i] = (byte) 0;  
             }  
             System.arraycopy(bSpace, 0, bSend, bRecv.length, bSpace.length);  
         } else {  
             bSend = new byte[bRecv.length];  
             System.arraycopy(bRecv, 0, bSend, 0, bRecv.length);  
         }  
   
         return bSend;  
     }  
   
     /** 把ASCII 转成十六进制 */  
     public static String printHexString(byte[] b) {  
         String result = "";  
         for (int i = 0; i < b.length; i++) {  
             String hex = Integer.toHexString(b[i] & 0xFF);  
             if (hex.length() == 1) {  
                 hex = '0' + hex;  
             }  
             result = result + hex.toUpperCase();  
         }  
         return result;  
     }  
   
     /** 将十六进制字符串转换成原始字节数组 */  
     public static byte[] hexStr2ByteArr(String strIn) throws Exception {  
         byte[] arrB = strIn.getBytes();  
         int iLen = arrB.length;  
   
         byte[] arrOut = new byte[iLen / 2];  
         for (int i = 0; i < iLen; i = i + 2) {  
             String strTmp = new String(arrB, i, 2);  
             arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);  
         }  
         return arrOut;  
   
     }  
   
     /*** 去除不可见字符( byte 是0的不可见字符) */  
     public static byte[] removeNoSeeChar(byte[] srcBytes) {  
         ArrayList<Byte> listArr = new ArrayList<Byte>();  
         for (int i = 0; i < srcBytes.length; i++) {  
             listArr.add(srcBytes[i]);  
         }  
         lableB: for (int j = listArr.size() - 1; j >= 0; j--) {  
             if (listArr.get(j) == 0) {  
                 listArr.remove(listArr.get(j));  
             } else {  
                 // break;  
                 break lableB;  
             }  
         }  
         byte[] bs = new byte[listArr.size()];  
         for (int k = 0; k < listArr.size(); k++) {  
             bs[k] = listArr.get(k).byteValue();  
         }  
         return bs;  
     }  
   
 }  

工厂类：

[java]view plain copy 
   
 package com.hkrt.des;  
   
 public class DesFactory {  
     public static Encrypt getInstance(){  
         return new Des();  
     }  
   
 }  

测试结果：

[java]view plain copy 
   
 package com.hkrt.des;  
   
   
 public class DesTest {  
     public static void main(String[] args) {  
         String srcStr="456789你";  
         System.out.println("加密结果"+jiaMi(srcStr));  
         System.out.println("解密结果"+jieMi("DD543BEBCB344F9B"));  
     }  
     /** 
      * @param srcStr 原始数据 
      * @return 十六进制数据 
      */  
     private static String jiaMi(String srcStr){  
         String keyStr="123456";  
         String key = DesUtil.printHexString(DesUtil.fillByte(keyStr.getBytes()));//给key 补位 并转成十六进制  
         byte[] src = DesUtil.fillByte(srcStr.getBytes());//给src 补位  
         byte[]  result=null;  
         try {  
             result = DesFactory.getInstance().DesEncryptByte2(key, src);  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
         return DesUtil.printHexString(result);  
     }  
     /** 
      * @param srcStr 十六进制 
      * @return 真实数据 
      */  
     private static String jieMi(String srcStr){  
         String keyStr="123456";  
         String key = DesUtil.printHexString(DesUtil.fillByte(keyStr.getBytes()));//给key 补位 并转成十六进制  
         String result =null;  
         try {  
             result = DesFactory.getInstance().DesDecrypt(key, srcStr);  
         } catch (Exception e) {  
             e.printStackTrace();  
         }  
         return result;  
     }  
   
 }  