java aes 加密工具类

最新推荐文章于 2024-06-20 17:07:11 发布
最新推荐文章于 2024-06-20 17:07:11 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 工具类 安全 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ytrdgfdtr/article/details/123248480
版权 
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.directory.studio</groupId>
            <artifactId>org.apache.commons.codec</artifactId>
            <version>1.8</version>
        </dependency>

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.text.MessageFormat;



/**
 * @Date: 2022/3/1 15:10
 *
 *
 * ECB模式：又称电码本（ECB，Electronic Codebook Book）模式。这是最简单的块密码加密模式，加密前根据加密块大小（如AES为128位）分成若干块，
 * 之后将每块使用相同的密钥单独加密，解密同理。
 *
 * CBC模式：又称密码分组链接（CBC，Cipher-block chaining）模式。在这种加密模式中，每个密文块都依赖于它前面的所有明文块。
 * 同时，为了保证每条消息的唯一性，在第一个块中需要使用初始化向量IV。
 */
public class AESUtils {
    /**
     * AES加解密
     */
    private static final String ALGORITHM = "AES";
    /**
     * 默认的初始化向量值
     */
    private static final String IV_DEFAULT = "ssv20dsvOmIxsPuT";
    /**
     * 默认加密的KEY
     */
    private static final String KEY_DEFAULT = "ss5M4Ff9del8fUs0";
    /**
     * 工作模式：CBC
     */
    private static final String TRANSFORM_CBC_PKCS5 = "AES/CBC/PKCS5Padding";

    /**
     * 工作模式：ECB
     */
    private static final String TRANSFORM_ECB_PKCS5 = "AES/ECB/PKCS5Padding";

    /**
     * 基于CBC工作模式的AES加密
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param value 待加密字符串
     * @param key 秘钥，如果不填则使用默认值
     * @param iv 初始化向量值，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String encryptCbcMode(final String value, String key, String iv){
        if(StringUtils.isNoneBlank(value)){
            //如果key或iv为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }
            if(iv == null || iv.length() != 16){
                iv = IV_DEFAULT;
            }

            //密码
            final SecretKeySpec keySpec = getSecretKey(key);

            //初始化向量器
            final IvParameterSpec ivParameterSpec = new IvParameterSpec(getUTF8Bytes(iv));

            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_CBC_PKCS5);

                //加密模式
                encipher.init(Cipher.ENCRYPT_MODE, keySpec, ivParameterSpec);
                //使用AES加密
                byte[] encrypted = encipher.doFinal(getUTF8Bytes(value));
                //然后转成BASE64返回
                return Base64.encodeBase64String(encrypted);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于CBC工作模式的AES加密失败,VALUE:{0},KEY:{1}",value,key));
                e.printStackTrace();
            }
        }

        return null;
    }

    /**
     * 基于CBC工作模式的AES解密
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param encryptedStr AES加密之后的字符串
     * @param key 秘钥，如果不填则使用默认值
     * @param iv 初始化向量值，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String decryptCbcMode(final String encryptedStr, String key, String iv){
        if(StringUtils.isNoneBlank(encryptedStr)){
            //如果key或iv为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }
            if(iv == null || iv.length() != 16){
                iv = IV_DEFAULT;
            }

            //密码
//            final SecretKeySpec keySpec = new SecretKeySpec(getUTF8Bytes(key),"AES");
            final SecretKeySpec keySpec = getSecretKey(key);
//            初始化向量器
            final IvParameterSpec ivParameterSpec = new IvParameterSpec(getUTF8Bytes(iv));

            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_CBC_PKCS5);

                //加密模式
                encipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
                //先用BASE64解密
                byte[] encryptedBytes = Base64.decodeBase64(encryptedStr);
                //然后再AES解密
                byte[] originalBytes = encipher.doFinal(encryptedBytes);
                //返回字符串
                return new String(originalBytes);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于CBC工作模式的AES解密失败,encryptedStr:{0},KEY:{1}",encryptedStr,key));
                e.printStackTrace();
            }
        }

        return null;
    }


    /**
     * 基于ECB工作模式的AES加密
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param value 待加密字符串
     * @param key 秘钥，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String encryptEcbMode(final String value, String key){
        if(StringUtils.isNoneBlank(value)){
            //如果key为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }

            //密码
            final SecretKeySpec keySpec = getSecretKey(key);

            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_ECB_PKCS5);

                //加密模式
                encipher.init(Cipher.ENCRYPT_MODE, keySpec);
                //使用AES加密
                byte[] encrypted = encipher.doFinal(getUTF8Bytes(value));
                //然后转成BASE64返回
                return Base64.encodeBase64String(encrypted);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于ECB工作模式的AES加密失败,VALUE:{0},KEY:{1}",value,key));
                e.printStackTrace();
            }
        }

        return null;
    }

    /**
     * 基于ECB工作模式的AES解密
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param encryptedStr AES加密之后的字符串
     * @param key 秘钥，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String decryptEcbMode(final String encryptedStr, String key){
        if(StringUtils.isNoneBlank(encryptedStr)){
            //如果key为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }

            //密码
            final SecretKeySpec keySpec = getSecretKey(key);

            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_ECB_PKCS5);

                //加密模式
                encipher.init(Cipher.DECRYPT_MODE, keySpec);
                //先用BASE64解密
                byte[] encryptedBytes = Base64.decodeBase64(encryptedStr);
                //然后再AES解密
                byte[] originalBytes = encipher.doFinal(encryptedBytes);
                //返回字符串
                return new String(originalBytes);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于ECB工作模式的AES解密失败,encryptedStr:{0},KEY:{1}",encryptedStr,key));
                e.printStackTrace();
            }
        }

        return null;
    }

    /**
     * 将字符串转化为UTF8格式的byte数组
     *
     * @param input the input string
     * @return UTF8 bytes
     */
    private static byte[] getUTF8Bytes(String input) {
        return input.getBytes(StandardCharsets.UTF_8);
    }

    /**
     * 生成加密秘钥
     * @param KEY 明文秘钥
     * @return SecretKeySpec
     */
    private static SecretKeySpec getSecretKey(final String KEY) {
        //生成指定算法密钥
        KeyGenerator generator = null;

        try {
            SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
            random.setSeed(KEY.getBytes());

            generator = KeyGenerator.getInstance(ALGORITHM);

            //指定AES密钥长度（128、192、256）
            generator.init(256, random);

            //生成一个密钥
            SecretKey secretKey = generator.generateKey();
            //转换为AES专用密钥
            return new SecretKeySpec(secretKey.getEncoded(), ALGORITHM);
        } catch (NoSuchAlgorithmException ex) {
            System.out.println(MessageFormat.format("生成加密秘钥失败,KEY:{0}",KEY));
            ex.printStackTrace();
        }

        return null;
    }


//    public static void main(String[] args) throws Exception {
//        String encryptedStr = encryptCbcMode("hello world!", "4Ct7TyXZa19rgQKK999999", null);
//        System.out.println(encryptedStr);
//
//        String originalStr = decryptCbcMode(encryptedStr, "4Ct7TyXZa19rgQKK999999", null);
//        System.out.println(originalStr);
//
//    }

}

1.原始参考 Java实现AES加密解密_Rosa_zz的博客-CSDN博客_java解密aes

2.有问题根据 https://blog.csdn.net/qq_38366063/article/details/102903547

修改过

下面式1.2原始文章内容


 
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
 
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.text.MessageFormat;
 
/**
 * AES加解密
 *
 * @author zifangsky
 * @date 2018/8/14
 * @since 1.0.0
 */
public class AesUtils {
    /**
     * AES加解密
     */
    private static final String ALGORITHM = "AES";
    /**
     * 默认的初始化向量值
     */
    private static final String IV_DEFAULT = "g8v20drvOmIx2PuR";
    /**
     * 默认加密的KEY
     */
    private static final String KEY_DEFAULT = "8G5M4Ff9hel8fUA9";
    /**
     * 工作模式：CBC
     */
    private static final String TRANSFORM_CBC_PKCS5 = "AES/CBC/PKCS5Padding";
 
    /**
     * 工作模式：ECB
     */
    private static final String TRANSFORM_ECB_PKCS5 = "AES/ECB/PKCS5Padding";
 
    /**
     * 基于CBC工作模式的AES加密
     * @author zifangsky
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param value 待加密字符串
     * @param key 秘钥，如果不填则使用默认值
     * @param iv 初始化向量值，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String encryptCbcMode(final String value, String key, String iv){
        if(StringUtils.isNoneBlank(value)){
            //如果key或iv为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }
            if(iv == null || iv.length() != 16){
                iv = IV_DEFAULT;
            }
 
            //密码
//            final SecretKeySpec keySpec = new SecretKeySpec(getUTF8Bytes(key),"AES");
            final SecretKeySpec keySpec = getSecretKey(key);
 
            //初始化向量器
            final IvParameterSpec ivParameterSpec = new IvParameterSpec(getUTF8Bytes(iv));
 
            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_CBC_PKCS5);
 
                //加密模式
                encipher.init(Cipher.ENCRYPT_MODE, keySpec, ivParameterSpec);
                //使用AES加密
                byte[] encrypted = encipher.doFinal(getUTF8Bytes(value));
                //然后转成BASE64返回
                return Base64.encodeBase64String(encrypted);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于CBC工作模式的AES加密失败,VALUE:{0},KEY:{1}",value,key));
                e.printStackTrace();
            }
        }
 
        return null;
    }
 
    /**
     * 基于CBC工作模式的AES解密
     * @author zifangsky
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param encryptedStr AES加密之后的字符串
     * @param key 秘钥，如果不填则使用默认值
     * @param iv 初始化向量值，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String decryptCbcMode(final String encryptedStr, String key, String iv){
        if(StringUtils.isNoneBlank(encryptedStr)){
            //如果key或iv为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }
            if(iv == null || iv.length() != 16){
                iv = IV_DEFAULT;
            }
 
            //密码
//            final SecretKeySpec keySpec = new SecretKeySpec(getUTF8Bytes(key),"AES");
            final SecretKeySpec keySpec = getSecretKey(key);
//            初始化向量器
            final IvParameterSpec ivParameterSpec = new IvParameterSpec(getUTF8Bytes(iv));
 
            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_CBC_PKCS5);
 
                //加密模式
                encipher.init(Cipher.DECRYPT_MODE, keySpec, ivParameterSpec);
                //先用BASE64解密
                byte[] encryptedBytes = Base64.decodeBase64(encryptedStr);
                //然后再AES解密
                byte[] originalBytes = encipher.doFinal(encryptedBytes);
                //返回字符串
                return new String(originalBytes);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于CBC工作模式的AES解密失败,encryptedStr:{0},KEY:{1}",encryptedStr,key));
                e.printStackTrace();
            }
        }
 
        return null;
    }
 
 
    /**
     * 基于ECB工作模式的AES加密
     * @author zifangsky
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param value 待加密字符串
     * @param key 秘钥，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String encryptEcbMode(final String value, String key){
        if(StringUtils.isNoneBlank(value)){
            //如果key为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }
 
            //密码
            final SecretKeySpec keySpec = getSecretKey(key);
 
            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_ECB_PKCS5);
 
                //加密模式
                encipher.init(Cipher.ENCRYPT_MODE, keySpec);
                //使用AES加密
                byte[] encrypted = encipher.doFinal(getUTF8Bytes(value));
                //然后转成BASE64返回
                return Base64.encodeBase64String(encrypted);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于ECB工作模式的AES加密失败,VALUE:{0},KEY:{1}",value,key));
                e.printStackTrace();
            }
        }
 
        return null;
    }
 
    /**
     * 基于ECB工作模式的AES解密
     * @author zifangsky
     * @date 2018/8/14 11:42
     * @since 1.0.0
     * @param encryptedStr AES加密之后的字符串
     * @param key 秘钥，如果不填则使用默认值
     * @return java.lang.String
     */
    public static String decryptEcbMode(final String encryptedStr, String key){
        if(StringUtils.isNoneBlank(encryptedStr)){
            //如果key为空，则使用默认值
            if(key == null || key.length() != 16){
                key = KEY_DEFAULT;
            }
 
            //密码
            final SecretKeySpec keySpec = getSecretKey(key);
 
            try {
                Cipher encipher = Cipher.getInstance(TRANSFORM_ECB_PKCS5);
 
                //加密模式
                encipher.init(Cipher.DECRYPT_MODE, keySpec);
                //先用BASE64解密
                byte[] encryptedBytes = Base64.decodeBase64(encryptedStr);
                //然后再AES解密
                byte[] originalBytes = encipher.doFinal(encryptedBytes);
                //返回字符串
                return new String(originalBytes);
            } catch (Exception e) {
                System.out.println(MessageFormat.format("基于ECB工作模式的AES解密失败,encryptedStr:{0},KEY:{1}",encryptedStr,key));
                e.printStackTrace();
            }
        }
 
        return null;
    }
 
    /**
     * 将字符串转化为UTF8格式的byte数组
     *
     * @param input the input string
     * @return UTF8 bytes
     */
    private static byte[] getUTF8Bytes(String input) {
        return input.getBytes(StandardCharsets.UTF_8);
    }
 
    /**
     * 生成加密秘钥
     * @param KEY 明文秘钥
     * @return SecretKeySpec
     */
    private static SecretKeySpec getSecretKey(final String KEY) {
        //生成指定算法密钥
        KeyGenerator generator = null;
 
        try {
            generator = KeyGenerator.getInstance(ALGORITHM);
 
            //指定AES密钥长度（128、192、256）
            generator.init(256, new SecureRandom(getUTF8Bytes(KEY)));
 
            //生成一个密钥
            SecretKey secretKey = generator.generateKey();
            //转换为AES专用密钥
            return new SecretKeySpec(secretKey.getEncoded(), ALGORITHM);
        } catch (NoSuchAlgorithmException ex) {
            System.out.println(MessageFormat.format("生成加密秘钥失败,KEY:{0}",KEY));
            ex.printStackTrace();
        }
 
        return null;
    }
 
    public static void main(String[] args) {
        String encryptedStr = AesUtils.encryptCbcMode("hello world!", "4Ct7TyXZa19rgQKK", null);
        System.out.println(encryptedStr);
 
        String originalStr = AesUtils.decryptCbcMode(encryptedStr, "4Ct7TyXZa19rgQKK", null);
        System.out.println(originalStr);
 
        String encryptedStr2 = AesUtils.encryptEcbMode("{\"username\":\"Tom\",\"password\":\"123456\",\"mobile\":\"12306\",\"email\":\"admin@zifangsky.cn\"}", "4Ct7TyXZa19rgQKK");
        String originalStr2 = AesUtils.decryptEcbMode(encryptedStr2, "4Ct7TyXZa19rgQKK");
        System.out.println(originalStr2);
 
    }
 
}

2.

错

private Key initKeyForAES(String key) throws NoSuchAlgorithmException {
        if (null == key || key.length() == 0) {
            throw new NullPointerException("key not is null");
        }
        SecretKeySpec key2 = null;try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, new SecureRandom(key.getBytes()));
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            key2 = new SecretKeySpec(enCodeFormat, "AES");
        } catch (NoSuchAlgorithmException ex) {
            throw new NoSuchAlgorithmException();
        }
        return key2;

    }

 修改后

private Key initKeyForAES(String key) throws NoSuchAlgorithmException {
        if (null == key || key.length() == 0) {
            throw new NullPointerException("key not is null");
        }
        SecretKeySpec key2 = null;
        SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
        random.setSeed(key.getBytes());
        try {
            KeyGenerator kgen = KeyGenerator.getInstance("AES");
            kgen.init(128, random);
            SecretKey secretKey = kgen.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            key2 = new SecretKeySpec(enCodeFormat, "AES");
        } catch (NoSuchAlgorithmException ex) {
            throw new NoSuchAlgorithmException();
        }
        return key2;

    }

赶紧去巡山
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Android AES加密工具类分享
09-04
【Android AES加密工具类分享】 在Android开发中，安全传输和存储数据是至关重要的，为此，开发者常常采用加密技术来保护敏感信息。本文将详细介绍一个基于AES（Advanced Encryption Standard）加密的Android工具类...
AES加密工具类
03-20
AES加密解密工具类，解决windows下和linux加密解密不同问题。
Java 使用mybatis的BaseTypeHandler实现数据自动AES加密解密，通过Hutool工具类自定义注解实现数据脱【附有完整步骤和代码】
weixin_44934104的博客
12-15 4193
此时在mybatis plus中是可以正常使用的，但是当我们在xml中自定义SQL文件时无效，这时需要在xml中定义resultMap(1) 在实体中设置:autoResultMap = true@Data(2)在xml中设置返回数据类型1）xml中自定义sql 返回实体类不能解密，返回resultMap在map中配置typeHandler可以解密。2）自带的wrappers更新不能加密，需要将数据加密后更新。//自定义MY_RULE,//用户idUSER_ID,
Java 实现 AES 加密和解密完整示例
热门推荐
蜗牛的博客
05-12 2万+
AES，全称为 Advanced Encryption Standard，是一种分组密码算法，用于保护敏感数据的传输和存储。AES 分为 128 位和 256 位两种密钥长度，可以对数据进行加密和解密，保证数据的安全性和完整性。AES 主要应用于电子商务、移动支付、网络安全等领域，被广泛运用于现代社会的各个方面。AES 算法被设计为高度安全，可以在理论上保证其分组密码的安全性。然而，由于其复杂性和密钥长度，AES 算法的实现和应用也具有一定的技术难度。
Java AES加密工具类
最新发布
cl617287的博客
06-20 419
在做AES加密的时候一定要注意private static final String DEFAULT_CIPHER_ALGORITHM = “AES/ECB/PKCS5Padding” 这个参数，很多时候前后端加密解密不一致都是这里配置不一致导致的。如果明文数据不是 16 字节的倍数，就需要进行填充。缺点是相同的明文块会被加密成相同的密文块，容易受到模式分析攻击，因此不适合加密大数据或高安全性需求的场景。举例来说，如果你加密的文本有很多重复的模式，使用 ECB 模式会暴露这些重复模式的信息，降低安全性。
【Java工具类】（27）—AES加密工具类
九离的博客
03-27 2028
Java工具类（27）—AES加密工具类 package com.awifi.cloudnative.container.common.utils; import java.io.UnsupportedEncodingException; import java.security.SecureRandom; import java.util.Random; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; imp
JAVA AES加密工具类
熊浪的博客
04-09 273
【代码】JAVA AES加密工具类。
java aes 工具类_Java中的AES加解密工具类：AESUtils
weixin_36336710的博客
02-12 954
本人手写已测试，大家可以参考使用package com.mirana.frame.utils.encrypt;import com.mirana.frame.constants.SysConstants;import com.mirana.frame.utils.RandomUtils;import com.mirana.frame.utils.SysPropUtils;import com.mi...
RSA+AES 加密工具类 Java
03-13
在这个“RSA+AES加密工具类 Java”中，我们将深入探讨这两种加密技术以及如何在Java环境中，包括Android和Web应用，实现它们。 首先，RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，基于大整数因子分解的困难...
JAVAAES对称加密工具类
02-27
在这个"JAVAAES对称加密工具类"中，我们主要探讨的是如何在Java中实现AES加密，并通过`EncryptUtil.java`这个类来处理字符串和文件流的加密操作。 AES加密算法基于替换和置换的过程，分为四个主要步骤：SubBytes、...
AES CBC加密
thorzdf的博客
05-21 136
import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import sun.misc.BASE64Decoder; import sun.misc.BASE64Encoder; ...
AES 加密解密
zsw_12345的博客
04-19 314
/* */ package cn.sccl.utils; /* */ /* */ import java.io.PrintStream; /* */ import javax.crypto.Cipher; /* */ import javax.crypto.spec.IvParameterSpec; /* */ import javax.cryp...
Java AES 加密解密工具类
Charge8的博客
04-15 3563
maven 引入一个依赖 <!-- https://mvnrepository.com/artifact/commons-codec/commons-codec --> <dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec<...
Java实现AES加密算法
laterstage的博客
07-09 1409
java AES代码示例
如何用java实现AES加密和解密
weixin_57604284的博客
05-12 2625
AES算法是一种对称加密算法，也就是说，加密和解密使用的是同一个密钥。它是美国国家标准技术研究所（NIST）在2001年选定的一种高级加密标准（Advanced Encryption Standard），用来替代之前的DES算法。AES算法的优点是安全性高、效率高、易于实现、不需要专利授权等。
AES对称加密算法扫盲
在折腾的年纪里的瞎折腾
05-22 8310
对称加密和分组加密中的四种模式(ECB、CBC、CFB、OFB) 一. AES对称加密:                                                       AES加密                          分组     二. 分组密码的填充
java：AES加密和解密
a232884c的博客
12-17 6653
对称加密，即单秘钥加密，指加密和解密的过程中，使用相同的秘钥，相比于非对称加密，因仅有一把钥匙，故而速度更快，更适合解密大文件（常见于如视频文件的加密解密中）。AES算法就属于对称加密中的一种。
java的AES对称加密和解密工具类AESUtils
CSDN86363160的博客
02-28 1263
此文为转载，原文请跳转至java的AES对称加密和解密，有偏移量 java的AES对称加密和解密，有偏移量 import java.math.BigDecimal; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import org.codehaus.jettison.json.JSONObject; import sun.misc.B
java aes加密 c 解密算法_JAVA实现AES的加密和解密算法
weixin_30590247的博客
02-13 487
import javax.crypto.spec.IvParameterSpec;import javax.crypto.spec.SecretKeySpec;import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;/**AES 是一种可逆加密算法，对用户的敏感信息加密处理* 对原始数据进行AES加密后，在进行Base64编码转化；*...
java aes加密工具类
03-31
以下是使用Java实现AES加密的工具类： ``` import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import java.security.MessageDigest; import java....
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值