AES和DES代码实现

最新推荐文章于 2024-05-06 18:26:10 发布
最新推荐文章于 2024-05-06 18:26:10 发布
阅读量245 收藏
点赞数
文章标签： java 移动开发
原文链接：https://juejin.im/post/5b7d4e6c51882542c11b15a8
版权

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技术分享，扫码关注微信公众号##
  • ——只要你学会了之前所不会的东西，只要今天的你强过了昨天的你，那你就一直是在进阶的路上了。
weixin_34124651
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python实现对称加密中3DES与AES算法工程文件
07-09
python实现对称加密中3DES与AES算法工程文件 详解博客地址：https://blog.csdn.net/m0_52316372/article/details/125691581
各种密码学算法的GUI编程实现（DES、AES、Present、扩展欧几里得算法、素性检测）
从入门到进错门
12-29 1万+
各种密码学算法的 C# GUI编程实现，包含：DES、AES、Present轻量级密码算法、扩展欧几里得算法、素性检测。
【Java】DES和AES两种双向加密的实现，简单好用，客户的初级开发很快就和我联调完成了，省心
极品小龙虾的博客
10-11 564
DES和AES两种双向加密的实现，实现起来比较好写。可能会问，为什么还有更多加密等级更高的或者不对等加密的算法，为什么不用那些呢？其中一个原因是，我这边服务的客户水平不一，但已经做到这个程度的加密往往对于他们已经足够。所以降低一些开发成本，用极可能简单好解释的策略，可以让客户快速理解并实现就更重要了。毕竟项目中尽快联调开发完成还是非常非常重要的。
Java：AES算法，DES算法实现简单的加密以及解密
tttheshuai的博客
03-27 1192
测试DES算法+CBC模式+PKCS5Padding填充模式结果。
密码学学习四-DES和AES代码实现
qq_35930102的博客
09-18 672
1 DES代码实现 import com.sun.org.apache.xml.internal.security.utils.Base64; import org.junit.Before; import org.junit.Test; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; /** * @author huwenlong * @date 2020/9/18 20:22 */ public cla
DES 和AES加密算法（python实现）
qq_43198387的博客
03-08 2053
DES 和AES加密算法（python实现） (1) DES算法 from Crypto.Cipher import DES from binascii import b2a_hex, a2b_hex class MyDESCrypt: def __init__(self, key=''): # 密钥长度必须为64位，也就是8个字节 if key != '': self.key = key.encode('utf-8') e
DES与AES实现
Hardict的算法日记
10-27 260
代码先扔这，区域赛打完来补 /* DES实现 Author: Hardict-龙鹏宇 E-mail: [email protected]/[email protected] */ #include <algorithm> #include <bitset> #include <cmath> #include <cstdio> #incl...
Java常用加密方案及实现——AES和DES
dengtuan6285的博客
07-30 178
　　AES和DES都是对称加密算法，其中DES全称为Data Encryption Standard，AES全称为Advanced Encryption Standard即高级加密标准。 　　DES现在已经不是一种安全的加密方法，主要因为它使用的56位密钥过短。尽管DES在安全上是脆弱的，但由于快速DES芯片的大量生产，使得DES仍能暂时继续使用，为提高安全强度，通常使用独立密钥的三级...
【转】C++实现AES、DES加密算法（含MFC界面）
01-11
AES（高级加密标准，Advanced Encryption Standard），在密码学中又称 Rijndael 加密法，...征集活动对 AES 的基本要求是： 比三重DES快、至少与三重DES一样安全、数据分组长度为128比特、密钥长度为128/192/256比特。
Java使用Hutool实现AES、DES加密解密的方法
08-29
本篇文章主要介绍了Java使用Hutool实现AES、DES加密解密的方法，具有一定的参考价值，有兴趣的可以了解一下
AES加密算法C语言代码实现
09-26
它的出现主要是为了取代DES加密算法的，因为我们都知道DES算法的密钥长度是56Bit，因此算法的理论安全强度是2的56次方。 AES密码与分组密码Rijndael基本上完全一致，Rijndael分组大小和密钥大小都可以为128位、192...
PHP对称加密算法（DES/AES）类的实现代码
10-18
本篇文章主要介绍了PHP对称加密算法（DES/AES）类的实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
matlab代码如何加密-Aes-Des-Implementation:使用Matlab和.NET的AES和DES加密/解密实现
05-24
该项目是AES和DES加密/解密算法的实现，当您运行该项目时，选择打开图像，选择您喜欢的加密算法，输入您的消息，对其进行加密，最后隐藏它在图像中。 1.0 如何设置？ 设置摘要 配置很简单，将其复制到本地存储库中，...
Java加密算法—对称加密(DES、AES)
热门推荐
一恍过去
02-16 1万+
Java加密算法—对称加密(DES、AES)
java实现对称加密AES和DES的加密、解密
零度的博客专栏
11-01 1万+
目前主流的加密方式有：1、对称加密：AES、DES      2、非对称加密：RSA、DSA。         本文主要讲解java实现调用AES/DES加密算法包，调用过程最精要的就是下面两句话： Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, key,
前后端(Java + Android + iOS) 一行代码实现DES加密解密算法
Dongxk的博客
06-21 361
一、Java实现： java实现方法和上一篇的AES一样，只需要把AES字段改成DES即可，具体可参考https://blog.csdn.net/Kevindongkun/article/details/92832373。 二、Android实现： 1. 加密 //text 待加密内容 key 公钥 长度32字符 public static String DESEncrypt(String t...
Linux下网络编程-简易Epll服务器和客户端
最新发布
weixin_45256307的博客
05-06 419
Linux下网络编程-简易Epll服务器和客户端
一篇文章，系统性聊聊Java注解
架构风清扬
05-06 1059
一篇文章，系统性聊聊Java注解
用python实现对称密码算法aes和des的代码
06-08
下面是使用Python实现AES和DES的示例代码： AES加密解密示例代码： ```python from Crypto.Cipher import AES import base64 # 加密函数 def aes_encrypt(key, data): cipher = AES.new(key.encode('utf-8'), ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值