java加密算法之AES篇

最新推荐文章于 2024-08-21 14:08:25 发布
最新推荐文章于 2024-08-21 14:08:25 发布
阅读量9.5k 收藏
点赞数
分类专栏： java工具类 java 算法 文章标签： java 加密解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42793960/article/details/117547878
版权
java 同时被 3 个专栏收录
19 篇文章 0 订阅
订阅专栏
算法
12 篇文章 0 订阅
订阅专栏
java工具类
10 篇文章 0 订阅
订阅专栏
加密
  字符串
public static String encode(String encodeKey,String content){
    try {
        KeyGenerator keygen= KeyGenerator.getInstance("AES");
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        random.setSeed(encodeKey.getBytes());
        keygen.init(128, random);
        SecretKey originalKey=keygen.generateKey();
        byte [] raw=originalKey.getEncoded();
        SecretKey key=new SecretKeySpec(raw, "AES");
        Security.addProvider(new BouncyCastleProvider());
        Cipher cipher=Cipher.getInstance("AES","BC");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] data = content.getBytes("utf-8");
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return MyBase64Utils.encodeStringForString(encryptedData);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
  map
public static String encode(String encodeKey, Map<String,Object> content){
    try {
        KeyGenerator keygen= KeyGenerator.getInstance("AES");
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
        random.setSeed(encodeKey.getBytes());
        keygen.init(128, random);
        SecretKey originalKey=keygen.generateKey();
        byte [] raw=originalKey.getEncoded();
        SecretKey key=new SecretKeySpec(raw, "AES");
        Security.addProvider(new BouncyCastleProvider());
        Cipher cipher=Cipher.getInstance("AES","BC");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] data = JsonUtils.toJson(content).getBytes();
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return MyBase64Utils.encodeStringForString(encryptedData);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
解密
public static String decode(String encodeKey,String decodeContent){
   try {
        KeyGenerator keygen=KeyGenerator.getInstance("AES");
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG",  "SUN");
        random.setSeed(encodeKey.getBytes());
        keygen.init(128, random);
        SecretKey originalKey=keygen.generateKey();
        byte [] raw=originalKey.getEncoded();
        SecretKey key=new SecretKeySpec(raw, "AES");
        Security.addProvider(new BouncyCastleProvider());
        Cipher cipher=Cipher.getInstance("AES","BC");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] encryptedData = MyBase64Utils.decodeStringForByte(decodeContent);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
测试
 public static void main(String[] args) {
     String encode = encode("128742634", "I'm encode content");
     String decode = decode("128742634", encode);
     System.out.println("Decode result is :"+decode);
 }
测试结果

在这里插入图片描述

全代码
public class AESUtils {

    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;


    public static String encode(String encodeKey,String content){
        try {
            KeyGenerator keygen= KeyGenerator.getInstance("AES");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(encodeKey.getBytes());
            keygen.init(128, random);
            SecretKey originalKey=keygen.generateKey();
            byte [] raw=originalKey.getEncoded();
            SecretKey key=new SecretKeySpec(raw, "AES");
            Security.addProvider(new BouncyCastleProvider());
            Cipher cipher=Cipher.getInstance("AES","BC");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] data = content.getBytes("utf-8");
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return MyBase64Utils.encodeStringForString(encryptedData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String encode(String encodeKey, Map<String,Object> content){
        try {
            KeyGenerator keygen= KeyGenerator.getInstance("AES");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG", "SUN");
            random.setSeed(encodeKey.getBytes());
            keygen.init(128, random);
            SecretKey originalKey=keygen.generateKey();
            byte [] raw=originalKey.getEncoded();
            SecretKey key=new SecretKeySpec(raw, "AES");
            Security.addProvider(new BouncyCastleProvider());
            Cipher cipher=Cipher.getInstance("AES","BC");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] data = JsonUtils.toJson(content).getBytes();
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            return MyBase64Utils.encodeStringForString(encryptedData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static String decode(String encodeKey,String decodeContent){
        try {
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG",  "SUN");
            random.setSeed(encodeKey.getBytes());
            keygen.init(128, random);
            SecretKey originalKey=keygen.generateKey();
            byte [] raw=originalKey.getEncoded();
            SecretKey key=new SecretKeySpec(raw, "AES");
            Security.addProvider(new BouncyCastleProvider());
            Cipher cipher=Cipher.getInstance("AES","BC");
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte[] encryptedData = MyBase64Utils.decodeStringForByte(decodeContent);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return new String(decryptedData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    
    public static void main(String[] args) {
        String encode = encode("128742634", "I'm encode content");
        String decode = decode("128742634", encode);
        System.out.println("Decode result is :"+decode);
    }
}

>>>源码下载链接>>>

lwx-apollo
关注
专栏目录
Java 中的加密算法： AES
叉叉哥的BLOG
08-07 922
加密算法 加密算法通常分为对称加密算法和非对称加密算法： 对称加密算法（symmetric-key cryptography）：加密和解密时使用相同的密钥。常用的对称加密算法有 DES、AES。 非对称加密算法（asymmetric-key cryptography）：加密和解密使用不同的密钥，例如公钥加密的内容只能用私钥解密，所以又称为公钥加密算法（public-key cryptography）。使用最广泛的非对称加密算法是 RSA 算法。 两者有不同的使用场景，而且经常会一起搭配起来使用，例如 S
java加密算法之对称加密算法AES
wjianwei666的专栏
05-31 908
AES（Advanced Encryption Standard）是美国联邦政府采用的一种对称加密标准，它在2001年取代了DES成为新的加密标准。AES是由比利时密码学家Vincent Rijmen和Joan Daemen共同提出的，其原名为Rijndael加密算法。
Java实现AES加密算法
m0_60252632的博客
02-21 9540
一、AES简介 高级加密标准（AES，Advanced Encryption Standard）为最常见的对称加密算法。 对称加密算法：加密和解密用相同的密钥。 图解： 介绍： 明文 P 没有经过加密的原始数据 密钥 K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的，密钥为发送方与接收方协商产生，但不可以直接在网络上传输，否则会导致密钥泄露，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥 AES 加密函数 设AES加密函数为
【Java】全网最详细的对称加密AES详解
最新发布
weixin_43219644的博客
08-21 3288
AES（Advanced Encryption Standard，高级加密标准）是一种对称加密算法，用于加密电子数据。它是由比利时密码学家Joan Daemen和Vincent Rijmen设计的，并于2001年由美国国家标准与技术研究院（NIST）采纳为官方标准。
AES.rar_AES_AES加密 java_AES算法_aes java_java aes
09-20
AES，全称为“Advanced Encryption Standard”，即高级加密标准，是目前广泛使用的对称加密算法。它在2001年由NIST（美国国家标准与技术研究所）正式采纳，取代了之前的DES（数据加密标准）成为新的标准加密算法。 ...
js java 加密算法_AES（对称加密算法）的JS实现和JAVA实现
weixin_31966185的博客
02-12 1272
文首声明：本文不讲算法实现AES介绍AES算法是一种典型的对称加密算法，不同于md5这种摘要算法是不可逆的，AES是可以通过秘钥解密的，一般用于对私密信息的保密。md5算法一般用文件的完整性校验，可以根据文件的所有的字节生成一个md5，也经常用于登录的鉴权，将密码的md5值存于数据库，登录时比较前端输入的密码的md5值和数据库的md5值。AES算法中有三个重要的定义：秘钥，加密模式，填充秘钥AES...
Java实现的对称加密算法AES定义与用法详解
08-27
"Java实现的对称加密算法AES定义与用法详解" 对称加密算法AES是当前使用最多的加密算法之一，其主要特点是高级的、安全的、快速的和灵活的。下面我们将详细介绍Java实现的对称加密算法AES的定义、特点、用法及使用...
java实现AES可逆加密算法
08-26
Java 实现 AES 可逆加密算法 在 Java 中实现 AES 可逆加密算法是一个非常实用的技术， AES（Advanced Encryption Standard）是一种对称加密算法，使用同一个密钥进行加密和解密。下面我们将详细介绍 Java 实现 AES ...
AES加密算法（java）实现
01-15
AES高级加密标准，在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。本软件是用java语言开发，实现了AES算法对文件的加密和解密，并在界面上加了进度条，来提示用户加密解密的进度。如果不足之处，欢迎留言。
Java版AES加密算法，亲测可用
08-29
Java版AES加密算法，亲测可用
Java实现AES加密和解密算法
11-05
本文就简单介绍如何通过JAVA实现AES加密： /** * 测试AES加密和解密 * @param args */ public static void main(String[] args) { /**数据初始化**/ String content = "http://www.mbaike.net"; String password = "1234567890"; /**加密(1)**/ System.out.println("加密前：" + content); byte[] encryptResult = encrypt(content, password); String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后：" + encryptResultStr); /**解密(2)**/ byte[] decryptFrom = parseHexStr2Byte(encryptResultStr); byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后：" + new String(decryptResult)); } } 说明如下： 在demo中使用了两个转换方法，及二进制转化成十六进制，和十六进制转化成二进制； 我们在AES加密的时候需要使用一个加密算的公共密钥来实现加密和解密； 加密后的字节数组不能直接转化为字符串，需要我们通过给出的两个方法转化；
java的加密算法原理_Java加密算法 AES详解
weixin_34867001的博客
02-28 327
import java.util.Arrays;import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.IvParameterSpec;/*** AES 算法 对称加密，密码学中的高级加密标准 2005年成为有效标准* @au...
AES加密算法java实现
weixin_40224981的博客
07-23 1014
转载自： https://blog.csdn.net/zyhlwzy/article/details/77948165 AES加密算法是密码学中的高级加密标准，该加密算法采用对称分组密码体制，密钥长度的最少支持为128、192、256，分组长度128位，算法应易于各种硬件和软件实现。这种加密算法是美国联邦政府采用的区块加密标准，这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。 过多...
AES加密算法，JAVA实现示例
热门推荐
gfaming的博客
04-26 1万+
最近项目上需要用到数据加密存储，查询资料后发现目前AES加密算法安全度非常高，具体原理可自行百度。但经网上搜到的JAVA实现示例运行都有各种问题，耗时一下午，终于调试运行成功，闲话少说，直接上代码。
Java实现加密——AES加密算法
weixin_41755554的博客
08-09 1566
高级加密标准（AES，Advanced Encryption Standard）为最常见的。对称加密算法：加密和解密用相同的密钥。
JAVA实现AES加密算法详解
AES是一种广泛使用的对称加密算法，它以128位的数据块进行操作，提供了高安全性和效率。在Java版本的AES算法实现中，可能会遇到加密速度不理想的问题，但其核心原理保持不变。 AES算法的核心包括以下几个步骤： 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

lwx-apollo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值