AES和DES程式碼實現

YunSoul發表於2018-08-22

DES是一種對稱加密演算法，所謂對稱加密演算法即：加密和解密使用相同金鑰的演算法。因為DES使用56位金鑰，以現代計算能力，24小時內即可被破解。雖然如此，在某些簡單應用中，我們還是可以使用DES加密演算法。

AES已經變成目前對稱加密中最流行演算法之一；AES可以使用128、192、和256位金鑰，並且用128位分組加密和解密資料。

package com.zyt;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.lang.reflect.Array;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.SecretKeySpec;

/**
/**
 * @ClassName: Test_DES_AES 
 * @Model : (所屬模組名稱)
 * @Description: (這裡用一句話描述這個類的作用) 
 * @author Administrator 
 * @date 2017年6月20日 下午3:02:45 
 */
public class Test_DES_AES {

    /**
    /**
     * main (這裡用一句話描述這個方法的作用) 
     * @param args
     * void 
     * @ModifiedPerson Administrator
     * @date 2017年6月20日 下午3:02:45 
     */
    public static void main(String[] args) {
        //*****************************AES或DES加密 解密字串*****************************
        //待加密內容  
        String str = "test";  
        //密碼，長度要是8的倍數  
        String password = "12345678aa";  
        
        byte[] desEncryptResult = DESEncrypt(str.getBytes(), password);
        System.out.println("DES加密‘測試內容’的結果是：" + new String(desEncryptResult));
        
        byte[] desDecrypt = DESDecrypt(desEncryptResult, password);
        System.out.println("DES解密的結果是：" + new String(desDecrypt));
        

        byte[] aesEncrypt = AESEncrypt(str, password);
        System.out.println("AES加密‘測試內容’的結果是：" + new String(aesEncrypt));
        
        byte[] aesDecrypt = AESDecrypt(aesEncrypt, password);
        System.out.println("AES解密的結果是：" + new String(aesDecrypt));
        
        //String srcFilePath = "D:\\11.txt";//原檔案
        String srcFilePath = "assets/11.txt";//原檔案

        //***************************** DES加密 解密檔案*****************************
        String encryptedFilePath = "assets/DES加密.txt";//加密後的檔案
        String decryptedFilePath = "assets/DES解密.txt";//解密後的檔案
        DESEncryptFile(srcFilePath, encryptedFilePath, password);
        DESDecryptFile(encryptedFilePath, decryptedFilePath, password);
        
        //***************************** AES加密 解密檔案  *****************************
        String AESencryptedFilePath = "assets/AES加密.txt";//加密後的檔案
        String AESdecryptedFilePath = "assets/AES解密.txt";//解密後的檔案
        AESEncryptFile(srcFilePath, AESencryptedFilePath, password);
        AESDecryptFile(AESencryptedFilePath, AESdecryptedFilePath, password);
    }
    
    //  注意：DES加密和解密過程中，金鑰password長度都必須是8的倍數
    public static byte[] DESEncrypt(byte[] datasource, String password){
        
        try {
            // DES演算法要求有一個可信任的隨機數源
            SecureRandom secureRandom = new SecureRandom();
            // 從原始密匙資料建立DESKeySpec物件
            DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
            // 建立一個密匙工廠，
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            //把DESKeySpec轉換成一個SecretKey物件
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // Cipher物件實際完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用密匙初始化Cipher物件  
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, secureRandom);
                                   
            // 執行加密操作
            return cipher.doFinal(datasource);
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return null;
    }
    
    //  注意：DES加密和解密過程中，金鑰password長度都必須是8的倍數
    public static byte[] DESDecrypt(byte[] encrypted, String password){
        try {
            // DES演算法要求有一個可信任的隨機數源
            SecureRandom secureRandom = new SecureRandom();
            // 建立一個DESKeySpec物件  
            DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
            // 建立一個密匙工廠  
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            // 將DESKeySpec物件轉換成SecretKey物件  
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // Cipher物件實際完成解密操作  
            Cipher cipher = Cipher.getInstance("DES");
            // 用密匙初始化Cipher物件  
            cipher.init(Cipher.DECRYPT_MODE, secretKey, secureRandom);
            // 真正開始解密操作  
            return cipher.doFinal(encrypted);
            
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        return null;
    }
    
  //DES解密檔案
    public static void DESDecryptFile(String encryptedFilePath, String decryptedFilePath, String password) {
        try {
            
            // DES演算法要求有一個可信任的隨機數源
            SecureRandom secureRandom = new SecureRandom();
            // 從原始密匙資料建立DESKeySpec物件
            DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
            // 建立一個密匙工廠，
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            //把DESKeySpec轉換成一個SecretKey物件
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // Cipher物件實際完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用密匙初始化Cipher物件  
            cipher.init(Cipher.DECRYPT_MODE, secretKey, secureRandom);
            
            //將檔案中的資料讀入
            FileInputStream fis = new FileInputStream(encryptedFilePath);
            //輸出解密資料到檔案
            FileOutputStream fos = new FileOutputStream(decryptedFilePath);
            

            //方法一：
            /*CipherInputStream cis = new CipherInputStream(fis, cipher);
            byte[] b = new byte[1024];
            int i = 0;
            while( (i = cis.read(b)) != -1 ){
                fos.write(b, 0, i);
            }
            
            cis.close();
            */
            

            //方法二：
            byte[] bb = new byte[1024];
            int l = 0;
            while((l = fis.read(bb)) != -1){
                byte[] doFinal = cipher.doFinal(Arrays.copyOfRange(bb, 0, l));
                fos.write(doFinal, 0, doFinal.length);
            }
            
            fos.close();
            fis.close();

            System.out.println("DES解密檔案結束");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        
    }

    //DES加密檔案
    public static void DESEncryptFile(String srcFilePath, String desFilePath, String password) {
        try {
            
            // DES演算法要求有一個可信任的隨機數源
            SecureRandom secureRandom = new SecureRandom();
            // 從原始密匙資料建立DESKeySpec物件
            DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
            // 建立一個密匙工廠，
            SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
            //把DESKeySpec轉換成一個SecretKey物件
            SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
            // Cipher物件實際完成加密操作
            Cipher cipher = Cipher.getInstance("DES");
            //用密匙初始化Cipher物件  
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, secureRandom);
            
            
            //將檔案中的資料讀入
            FileInputStream fis = new FileInputStream(srcFilePath);
            //輸出加密資料到檔案
            FileOutputStream fos = new FileOutputStream(desFilePath);
            
            //方法一：
            /*CipherInputStream cis = new CipherInputStream(fis, cipher);
            byte[] b = new byte[1024];
            int i = 0;
            while( (i = cis.read(b)) != -1 ){
                fos.write(b, 0, i);
            }
            cis.close();*/
            
            //方法二：
            byte[] bb = new byte[1024];
            int l = 0;
            while((l = fis.read(bb)) != -1){
                byte[] doFinal = cipher.doFinal(Arrays.copyOfRange(bb, 0, l));
                fos.write(doFinal, 0, doFinal.length);
            }
            
            fos.close();
            fis.close();

            System.out.println("DES加密檔案結束");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
        
    }
    
    public static byte[] AESEncrypt(String content, String password){
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128, new SecureRandom(password.getBytes()));
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, "AES");
            //建立密碼器
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            
            
            //真正的加密
            byte[] result = cipher.doFinal(content.getBytes("utf-8"));
            return result;
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return null;
    }
    
    public static byte[] AESDecrypt(byte[] content, String password){
        try {
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128, new SecureRandom(password.getBytes()));
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, "AES");
            //建立解密器
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
            
            
            //真正的解密
            byte[] result = cipher.doFinal(content);
            
            return result;
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
        
    }
    

    //AES加密檔案
    public static void AESEncryptFile(String srcFilePath, String AESencryptedFilePath, String password) {
       
        try { SecureRandom secureRandom = new SecureRandom(password.getBytes());
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128, secureRandom);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            
            
            //將檔案中的資料讀入
            FileInputStream fis = new FileInputStream(srcFilePath);
            //輸出加密資料到檔案
            FileOutputStream fos = new FileOutputStream(AESencryptedFilePath);
            CipherInputStream cis = new CipherInputStream(fis, cipher);
            byte[] b = new byte[1024];
            int i = 0;
            while( (i = cis.read(b)) != -1 ){
                fos.write(b, 0, i);
            }
            
            fos.close();
            cis.close();
            fis.close();

            System.out.println("AES加密檔案結束");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }   


    //AES解密檔案
    public static void AESDecryptFile(String AESencryptedFilePath, String AESdecryptedFilePath, String password) {
        try { SecureRandom secureRandom = new SecureRandom(password.getBytes());
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(128, secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();
        byte[] encoded = secretKey.getEncoded();
        SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        
        
        //將檔案中的資料讀入
        FileInputStream fis = new FileInputStream(AESencryptedFilePath);
        //輸出解密資料到檔案
        FileOutputStream fos = new FileOutputStream(AESdecryptedFilePath);
        CipherInputStream cis = new CipherInputStream(fis, cipher);
        byte[] b = new byte[1024];
        int i = 0;
        while( (i = cis.read(b)) != -1 ){
            fos.write(b, 0, i);
        }
        
        fos.close();
        cis.close();
        fis.close();

        System.out.println("AES解密檔案結束");
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
        
    }

}

複製程式碼

在Java專案中，上面的程式碼是完全能成功的，但在Android專案中，就會出現BadPaddingException: pad block corrupted in class SimpleCrypto in android，所以在Android中需要將祕鑰固定SHA1PRNG，否則會因為祕鑰不同而解密失敗。

//AES加密檔案
    public static void AESEncryptFile(InputStream is, String AESencryptedFilePath, String password) {
       
        try {
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG", "Crypto");
            secureRandom.setSeed(password.getBytes());
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128, secureRandom);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
            
            
            //輸出加密資料到檔案
            FileOutputStream fos = new FileOutputStream(AESencryptedFilePath);
            CipherInputStream cis = new CipherInputStream(is, cipher);
            byte[] b = new byte[1024];
            int i = 0;
            while( (i = cis.read(b)) != -1 ){
                fos.write(b, 0, i);
            }
            
            fos.close();
            cis.close();

            Log.i("?????", "AES加密檔案結束");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }   


    //AES解密檔案
    public static void AESDecryptFile(InputStream is, String AESdecryptedFilePath, String password) {
        try { 
            //在Android中需要將祕鑰固定SHA1PRNG，否則會因為祕鑰不同而解密失敗（BadPaddingException: pad block corrupted in class SimpleCrypto in android）
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG", "Crypto");
            secureRandom.setSeed(password.getBytes());
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128, secureRandom);
            SecretKey secretKey = keyGenerator.generateKey();
            byte[] encoded = secretKey.getEncoded();
            SecretKeySpec secretKeySpec = new SecretKeySpec(encoded, "AES");
            Cipher cipher = Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
            
            //輸出解密資料到檔案
            FileOutputStream fos = new FileOutputStream(AESdecryptedFilePath);
            CipherInputStream cis = new CipherInputStream(is, cipher);
            byte[] b = new byte[1024];
            int i = 0;
            while( (i = cis.read(b)) != -1 ){
                fos.write(b, 0, i);
            }
            
            //方法二：
            /*byte[] bb = new byte[1024];
            int l = 0;
            while((l = is.read(bb)) != -1){
                byte[] doFinal = cipher.doFinal(Arrays.copyOfRange(bb, 0, l));
                fos.write(doFinal, 0, doFinal.length);
            }
            */
            fos.close();
            cis.close();
    
            System.out.println("AES解密檔案結束");
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
        
    }
複製程式碼

#### YunSoul技術分享，掃碼關注微信公眾號##

DES原理及程式碼實現
2020-04-20
密碼學之DES/AES演算法
2019-02-16
密碼學演算法
DES/3DES/AES 三種對稱加密演算法在 Java 中的實現
2017-01-28
3D加密演算法Java
DES演算法C++程式碼實現-密碼學
2016-11-08
演算法C++密碼學
DES密碼的C++實現
2017-10-25
密碼C++
Java實現AES和RSA演算法
2018-08-17
Java演算法
python實現Simplified_DES （S-DES）
2020-10-07
Python
常用加密解密演算法【RSA、AES、DES、MD5】介紹和使用
2016-11-08
加密解密演算法
app直播原始碼，android AES加密解密實現
2023-10-18
APP原始碼Android加密解密
Golang 裡的 AES、DES、3DES 加解密，支援 ECB、CBC 等多種模式組合
2019-10-15
Golang3D解密模式
常用加解密工具類（MD5、SHA、DES、AES、RSA）
2016-01-22
解密
C語言實現DES加密
2017-03-30
C語言加密
api介面資料安全格式轉換-DES,AES,SM2
2024-08-11
API
OutputStreamWriter介紹&程式碼實現和InputStreamReader介紹&程式碼實現
2022-07-09
VB實現AES(Rijndael)加密的方法
2005-06-20
加密
java實現DES資料加密與解密
2017-09-06
Java加密解密
java 實現 DES加密解密演算法
2015-03-17
Java加密解密演算法
使用OpenSSL替代MCrypt實現AES加解密
2018-07-31
解密
AES加密 – iOS與Java的同步實現
2016-08-23
加密iOSJava
AES加密演算法的JAVA實現
2017-01-17
加密演算法Java
mqtt介紹和go程式碼實現
2019-02-16
MQQTGo
原創：微信小程式java實現AES解密並獲取unionId
2017-01-21
微信小程式Java解密
通過Go實現AES加密和解密工具
2022-05-12
Go加密解密
Golang實現ECB模式3DES演算法
2019-02-16
Golang模式3D演算法
AES加解密多版本（GO、JAVA、Python）實現
2018-02-03
解密GoJavaPython
android典型程式碼系列(三十)------DES加密演算法
2015-12-06
Android加密演算法
Promise 程式碼實現
2019-01-01
Promise
實現彩色二維碼程式碼實
2017-03-22
Locust 程式碼指令碼實現
2024-03-16
指令碼
AES實現財務資料的加密解密儲存
2020-06-01
加密解密
java使用DES加密方式，實現對資料的加密解密
2017-10-07
Java加密解密
用vb實現DES加解密演算法(三)--解密 (轉)
2007-11-25
解密演算法
用vb實現DES加解密演算法(二)--加密 (轉)
2007-11-25
解密演算法加密
深入理解DES演算法：原理、實現與應用
2024-04-14
演算法
MyCat分片：水平拆分例項解析和程式碼實現！
2021-03-22
jquery實現的下拉和收縮程式碼例項
2017-02-22
jQuery
markdown的流程圖實現和程式碼語法著色
2017-11-07
流程圖
如何實現程式碼高亮
2020-04-14

AES和DES程式碼實現

相關文章