精华内容
下载资源
问答
  • 该资源是AES加密工具类; 包括源码:AES256Util.java 及其必要jar包:bcprov-jdk16-141.jar 和 javabase64-1.3.1.jar
  • AES对称加密工具类

    2018-09-18 11:05:07
    AES对称加密工具类,本工具已经测试通过,不需要额外依赖,直接copy即可使用
  • JAVAAES对称加密工具类

    2018-02-27 16:49:14
    JAVA AES对称加密工具类,可实用;包含加密字符串和文件流
  • aes前端加密工具类.zip

    2019-07-31 10:16:03
    aes前端加密工具类.zip
  • Java AES256加密解密工具类

    千次阅读 2018-07-02 13:42:44
     System.out.println("密文:" + AES256Util.parseByte2HexStr(encryptResult));    String decryptResult = AES256Util.decrypt(encryptResult, password);  System.out.println("解密:" + decryptResult); ...

    package com.firebug.util;

    import it.sauronsoftware.base64.Base64;  

    import java.security.MessageDigest;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.SecureRandom;  
    import java.security.Security;  
     
    import javax.crypto.Cipher;  
    import javax.crypto.KeyGenerator;  
    import javax.crypto.SecretKey;  
    import javax.crypto.spec.SecretKeySpec;  
     
    import org.bouncycastle.jce.provider.BouncyCastleProvider;  

    public class AES256Util {

        public static byte[] encrypt(String content, String password) {  
            try {  
                //"AES":请求的密钥算法的标准名称  
                KeyGenerator kgen = KeyGenerator.getInstance("AES");  
                //256:密钥生成参数;securerandom:密钥生成器的随机源  
                SecureRandom securerandom = new SecureRandom(tohash256Deal(password));  
                kgen.init(256, securerandom);  
                //生成秘密(对称)密钥  
                SecretKey secretKey = kgen.generateKey();  
                //返回基本编码格式的密钥  
                byte[] enCodeFormat = secretKey.getEncoded();  
                //根据给定的字节数组构造一个密钥。enCodeFormat:密钥内容;"AES":与给定的密钥内容相关联的密钥算法的名称  
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
                //将提供程序添加到下一个可用位置  
                Security.addProvider(new BouncyCastleProvider());  
                //创建一个实现指定转换的 Cipher对象,该转换由指定的提供程序提供。  
                //"AES/ECB/PKCS7Padding":转换的名称;"BC":提供程序的名称  
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");  
     
                cipher.init(Cipher.ENCRYPT_MODE, key);  
                byte[] byteContent = content.getBytes("utf-8");  
                byte[] cryptograph = cipher.doFinal(byteContent);  
                return Base64.encode(cryptograph);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
     
        public static String decrypt(byte[] cryptograph, String password) {  
            try {  
                KeyGenerator kgen = KeyGenerator.getInstance("AES");  
                SecureRandom securerandom = new SecureRandom(tohash256Deal(password));  
                kgen.init(256, securerandom);  
                SecretKey secretKey = kgen.generateKey();  
                byte[] enCodeFormat = secretKey.getEncoded();  
                SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
                Security.addProvider(new BouncyCastleProvider());  
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding", "BC");  
     
                cipher.init(Cipher.DECRYPT_MODE, key);  
                byte[] content = cipher.doFinal(Base64.decode(cryptograph));  
                return new String(content);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return null;  
        }  
     
        private static String parseByte2HexStr(byte buf[]) {  
            StringBuffer sb = new StringBuffer();  
            for (int i = 0; i < buf.length; i++) {  
                String hex = Integer.toHexString(buf[i] & 0xFF);  
                if (hex.length() == 1) {  
                    hex = '0' + hex;  
                }  
                sb.append(hex.toUpperCase());  
            }  
            return sb.toString();  
        }  
          
        private static byte[] tohash256Deal(String datastr) {  
            try {  
                MessageDigest digester=MessageDigest.getInstance("SHA-256");  
                digester.update(datastr.getBytes());  
                byte[] hex=digester.digest();  
                return hex;   
            } catch (NoSuchAlgorithmException e) {  
                throw new RuntimeException(e.getMessage());    
            }  
        }  
          
        public static void main(String[] args) {  
     
            String content = "我是待加密的文本";  
            String password = "123456";  
            System.out.println("明文:" + content);  
            System.out.println("key:" + password);  
              
            byte[] encryptResult = AES256Util.encrypt(content, password);  
            System.out.println("密文:" + AES256Util.parseByte2HexStr(encryptResult));  
              
            String decryptResult = AES256Util.decrypt(encryptResult, password);  
            System.out.println("解密:" + decryptResult);  
        }

    }

    //refer: https://blog.csdn.net/z69183787/article/details/78043762

    //源码及其所需jar包下载:https://download.csdn.net/download/qq_37122091/10513591

    展开全文
  • AES对称加密工具类,代码如下: package com.sszh.utils.security; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; /** * AES对称加密工具类 ...

    AES对称加密工具类,代码如下:

    package com.sszh.utils.security;
    
    import javax.crypto.Cipher;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    
    /**
     * AES对称加密工具类
     */
    public class AesEncryption {
    
        /**
         * 加密数据
         *
         * @param data 明文
         * @param key  秘钥
         * @param iv   秘钥
         */
        public static String Encrypt(String data, String key, String iv) throws Exception {
            try {
                Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                int blockSize = cipher.getBlockSize();
                byte[] dataBytes = data.getBytes("UTF-8");
                int plaintextLength = dataBytes.length;
                if (plaintextLength % blockSize != 0) {
                    plaintextLength = plaintextLength
                            + (blockSize - (plaintextLength % blockSize));
                }
                byte[] plaintext = new byte[plaintextLength];
                System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
                SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
                IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
                cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);
                byte[] encrypted = cipher.doFinal(plaintext);
                return Base64Method.EncryptBase64(encrypted);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 解密数据
         *
         * @param data 密文
         * @param key  秘钥
         * @param iv   秘钥
         */
        public static String Desencrypt(String data, String key, String iv) throws Exception {
            try {
                byte[] encrypted1 = Base64Method.DecryptBase64ForByte(data);
                Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                SecretKeySpec keyspec = new SecretKeySpec(key.getBytes(), "AES");
                IvParameterSpec ivspec = new IvParameterSpec(iv.getBytes());
                cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);
                byte[] original = cipher.doFinal(encrypted1);
                String originalString = new String(original, "UTF-8");
                return originalString;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }
    
    
    展开全文
  • AES加密和解密的工具类,DLL可以直接引用到代码。支持WIN 7及以上版本。
  • 综合网上的AES加密,把其做成一个工具类,方便加密解密的实现
  • 1、AES加密工具类 java不支持PKCS7Padding,只支持PKCS5Padding。我们知道加密算法由算法+模式+填充组成,下一篇介绍iOS和Android通用的AES加密,本篇文章使用PKCS5Padding加密方式。 package com.example.aesdemo;...
  • AES256加密及解密

    2021-06-30 18:27:13
    提供AES256加密和逆向解密工具,内含java “bcprov-jdk16-141.jar”、“javabase64-1.3.1.jar” 本地架包,主要用于开放平台接口对接进行加密算法和逆向解密
  • Qt实现AES256加密

    2019-12-24 15:58:24
    运用Qt框架实现AES256加密字符串以及文件,并且支持AES128以及AES192进行字符串以及文件的加密,可供学习和研究
  • 需要配置AES_MODE(模式和填充)、AES_KEY(密钥)、AES_IV(偏移量) 至于是128还是192还是256,是根据密钥的长度自动确定的,且密钥长度只有三种:16、24、32 128的16位key,16位iv 192的24位key,16位iv 256的32...

    需要配置AES_MODE(模式和填充)、AES_KEY(密钥)、AES_IV(偏移量)

    至于是128还是192还是256,是根据密钥的长度自动确定的,且密钥长度只有三种:16、24、32

    128的16位key,16位iv
    192的24位key,16位iv
    256的32位key,16位iv
    

    测试地址:http://www.ssleye.com/aes_cipher.html

    import android.util.Base64;
    import android.util.Log;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidAlgorithmParameterException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    
    /**
     * author:wangjinqiang
     * date:2019/12/12
     */
    public class SecurityAES {
        private static final String TAG = "SecurityAES";
        /**
         * 模式/填充
         */
        private final static String AES_MODE = "AES/CBC/PKCS5PADDING";
        /**
         * AES加密时的秘钥
         * 128的16位key,16位iv
         * 192的24位key,16位iv
         * 256的32位key,16位iv
         */
        private final static String AES_KEY = "01234567890123456789012345678901";
        /**
         * 偏移量,长度必须16位,多了少了都不行
         */
        private final static String AES_IV = "0123456789012345";
        /**
         * AES专用秘钥
         */
        private static SecretKeySpec key = new SecretKeySpec(AES_KEY.getBytes(), "AES");
    
        static {
            Log.e(TAG, "数据块长度: " + AES_KEY.getBytes().length * 8);
        }
    
        /**
         * 加密文本
         *
         * @param content 明文
         * @return 加密后Base64的字符串
         */
        public static String encrypt(String content) {
            try {
                // 创建AES密码器
                Cipher cipher = Cipher.getInstance(AES_MODE);
                // 将文本进行utf-8的编码
                byte[] byteContent = content.getBytes("utf-8");
    
                //偏移量
                byte[] iv = AES_IV.getBytes();
                IvParameterSpec ivSpec = new IvParameterSpec(iv);
    
                // 初始化AES密码器为加密器
                cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
                // 进行AES加密
                byte[] result = cipher.doFinal(byteContent);
                // 将byte数组转为Base64字符串
                return Base64.encodeToString(result, Base64.NO_WRAP);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (InvalidAlgorithmParameterException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 解码文本
         *
         * @param encryptContent 密文(Base64)
         * @return 明文
         */
        public static String decrypt(String encryptContent) {
            try {
                byte[] content = Base64.decode(encryptContent, Base64.NO_WRAP);
                // 创建AES密码器
                Cipher cipher = Cipher.getInstance(AES_MODE);
                //偏移量
                byte[] iv = AES_IV.getBytes();
                IvParameterSpec ivSpec = new IvParameterSpec(iv);
                // 初始化AES密码器为解密器
                cipher.init(Cipher.DECRYPT_MODE, key, ivSpec);// 初始化
                // 进行AES解密
                byte[] result = cipher.doFinal(content);
                // 将二进制转为字符串
                return new String(result);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            } catch (IllegalBlockSizeException e) {
                e.printStackTrace();
            } catch (BadPaddingException e) {
                e.printStackTrace();
            } catch (InvalidAlgorithmParameterException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        /**
         * 将byte数组转换成16进制的字符串
         *
         * @param buf
         * @return 16进制的字符串
         */
        public static String parseByte2HexStr(byte buf[]) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < buf.length; i++) {
                //将每个字节都转成16进制的
                String hex = Integer.toHexString(buf[i] & 0xFF);
                if (hex.length() == 1) {
                    //为保证格式统一,用两位16进制的表示一个字节
                    hex = '0' + hex;
                }
                sb.append(hex.toUpperCase());
            }
            return sb.toString();
        }
    
        /**
         * 将16进制的字符串转换为byte数组
         *
         * @param hexStr
         * @return byte数组
         */
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr.length() < 1)
                return null;
            //两个16进制表示一个字节,所以字节数组大小为hexStr.length() / 2
            byte[] result = new byte[hexStr.length() / 2];
            for (int i = 0; i < hexStr.length() / 2; i++) {
                //每次获取16进制字符串中的两个转成10进制(0-255)
                int num = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 2), 16);
                //将10进制强转为byte
                result[i] = (byte) num;
            }
            return result;
        }
    }
    

     

    展开全文
  • AES加密工具类

    2018-03-20 17:08:47
    AES加密解密工具类,解决windows下和linux加密解密不同问题。
  • android AES加密工具类

    2016-07-20 11:14:02
    android 可以使用的 AES加密工具类
  • aes加密工具类

    2018-04-16 10:00:42
    用java编写的aes加密工具,内置加密、解密、测试的方法。
  • AES加密解密工具类

    2016-07-14 17:27:53
    AES加密解密工具类
  • RSA+AES 加密工具类 Java

    2018-03-13 09:53:45
    适用于Android、Java、Web端使用的AES、RSA加密工具类
  • 主要介绍了Java实现的AES256加密解密功能,结合完整实例形式分析了Java实现AES256加密解密功能的步骤与相关操作技巧,需要的朋友可以参考下
  • AES 256 加密

    2021-01-05 10:55:41
    AES 256加密 ,需要去oracle官网下载一个插件。放到JDK里面。 无限制JCE策略文件下载地址: JDK7的下载地址:https://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html JDK8的下载地址:...

     AES 256加密 ,需要去oracle官网下载一个插件。放到JDK里面。

    无限制JCE策略文件下载地址:
    JDK7的下载地址: https://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html
    JDK8的下载地址: http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html

    如需要可以留言,邮箱

    下面这个是我参考得,忘了是哪里了。。。 但是使用是可以的。

    package com.sgcc.zcqsm.reshandover.util;
    
    /**
     * @Title: AESUtils.java
     * @Description: AES密码工具类
     * @author liunn
     * @date 2020年9月9日12:22:57
     * @version V1.0
     */
    
    import org.apache.commons.codec.binary.Base64;
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.Provider;
    import java.security.SecureRandom;
    import java.security.Security;
    import java.util.Arrays;
    
    /**
     * @author liunn
     * @ClassName: AESUtils
     * @Description: aes对称加密解密工具类, 注意密钥不能随机生机, 不同客户端调用可能需要考虑不同Provider,
     * 考虑安卓与IOS不同平台复杂度,简化不使用Provider
     */
    public class AESUtils {
    
        /***默认向量常量**/
        public static final String IV = "1234567890123456";
        private final static Logger logger = LoggerFactory.getLogger(AESUtils.class);
    
        /**
         * 使用PKCS7Padding填充必须添加一个支持PKCS7Padding的Provider
         * 类加载的时候就判断是否已经有支持256位的Provider,如果没有则添加进去
         */
        static {
            if (Security.getProvider(BouncyCastleProvider.PROVIDER_NAME) == null) {
                Security.addProvider(new BouncyCastleProvider());
            }
        }
    
        /**
         * 加密 128位
         *
         * @param content 需要加密的原内容
         * @param pkey    密匙
         * @return
         */
        public static byte[] aesEncrypt(String content, String pkey) {
            try {
                //SecretKey secretKey = generateKey(pkey);
                //byte[] enCodeFormat = secretKey.getEncoded();
                SecretKeySpec skey = new SecretKeySpec(pkey.getBytes(), "AES");
                Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");// "算法/加密/填充"
                IvParameterSpec iv = new IvParameterSpec(IV.getBytes());
                cipher.init(Cipher.ENCRYPT_MODE, skey, iv);//初始化加密器
                byte[] encrypted = cipher.doFinal(content.getBytes("UTF-8"));
                return encrypted; // 加密
            } catch (Exception e) {
                logger.info("aesEncrypt() method error:", e);
            }
            return null;
        }
    
        /**
         * 获得密钥
         *
         * @param secretKey
         * @return
         * @throws Exception
         */
        private static SecretKey generateKey(String secretKey) throws Exception {
            //防止linux下 随机生成key
            Provider p = Security.getProvider("SUN");
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG", p);
            secureRandom.setSeed(secretKey.getBytes());
            KeyGenerator kg = KeyGenerator.getInstance("AES");
            kg.init(secureRandom);
            // 生成密钥
            return kg.generateKey();
        }
    
        /**
         * @param content 加密前原内容
         * @param pkey    长度为16个字符,128位
         * @return base64EncodeStr   aes加密完成后内容
         * @throws
         * @Title: aesEncryptStr
         * @Description: aes对称加密
         */
        public static String aesEncryptStr(String content, String pkey) {
            byte[] aesEncrypt = aesEncrypt(content, pkey);
            System.out.println("加密后的byte数组:" + Arrays.toString(aesEncrypt));
            String base64EncodeStr = Base64.encodeBase64String(aesEncrypt);
            System.out.println("加密后 base64EncodeStr:" + base64EncodeStr);
            return base64EncodeStr;
        }
    
        /**
         * @param content base64处理过的字符串
         * @param pkey    密匙
         * @return String    返回类型
         * @throws Exception 
         * @throws
         * @Title: aesDecodeStr
         * @Description: 解密 失败将返回NULL
         */
        public static String aesDecodeStr(String content, String pkey) throws Exception {
            try {
                System.out.println("待解密内容:" + content);
                byte[] base64DecodeStr = Base64.decodeBase64(content);
                System.out.println("base64DecodeStr:" + Arrays.toString(base64DecodeStr));
                byte[] aesDecode = aesDecode(base64DecodeStr, pkey);
                System.out.println("aesDecode:" + Arrays.toString(aesDecode));
                if (aesDecode == null) {
                    return null;
                }
                String result;
                result = new String(aesDecode, "UTF-8");
                System.out.println("aesDecode result:" + result);
                return result;
            } catch (Exception e) {
                System.out.println("Exception:" + e.getMessage());
                throw new Exception("解密异常");
            }
        }
    
        /**
         * 解密 128位
         *
         * @param content 解密前的byte数组
         * @param pkey    密匙
         * @return result  解密后的byte数组
         * @throws Exception
         */
        public static byte[] aesDecode(byte[] content, String pkey) throws Exception {
    
            //SecretKey secretKey = generateKey(pkey);
            //byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec skey = new SecretKeySpec(pkey.getBytes(), "AES");
            IvParameterSpec iv = new IvParameterSpec(IV.getBytes("UTF-8"));
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");// 创建密码器
            cipher.init(Cipher.DECRYPT_MODE, skey, iv);// 初始化解密器
            byte[] result = cipher.doFinal(content);
            return result; // 解密
    
        }
    
    
        public static void main(String[] args) throws Exception {
            //明文
            String content = "今天也要开心哦!";
            //密匙
            String pkey = "qwertyuiopqwertyuiopqwertyuiopqw";
            System.out.println("待加密报文:" + content);
            System.out.println("密匙:" + pkey);
            String aesEncryptStr = aesEncryptStr(content, pkey);
            System.out.println("加密报文:" + aesEncryptStr);
            String aesDecodeStr = aesDecodeStr(aesEncryptStr, pkey);
            System.out.println("解密报文:" + aesDecodeStr);
            System.out.println("加解密前后内容是否相等:" + aesDecodeStr.equals(content));
        }
    
    }

     

    展开全文
  • Silver Key 这是一个用于加密文件或者文件夹,生成可以在因特网上发送的自解密加密包的软件.Silver Key不需要你的通讯软件安装有任何加密软件.接收者解密数据唯一需要的就是正确的密码和密匙.当你
  • Aes加密解密工具类

    2020-02-09 17:23:08
    AES自定义16位字符串我加密字密码
  • Base64+ AES加密工具类 对称加密,十分的方便使用。可用于登录注册各种对称加密
  • aes256加密java 总览 由于最近爱德华·斯诺登 ( Edward Snowden)发布了文件,以及针对JC Penny , Sony和Target等在线商业商店的黑客攻击激增,安全性已成为近年来讨论的重要话题。 尽管本文不会为您提供帮助防止...
  • Altera FPGA AES256加密

    2020-08-26 11:51:11
    对于Intel FPGA有下面这些器件都支持AES加密,另外高端的S10,Agilex10这些也是支持的哈。 密钥又分为易失性和非易失性两种。 易失性密钥:是采用VBAT供电,密钥是存储在FPGA内部的ram里,一旦Vbat断电,密钥就丢失...
  • AESUtil AES加密工具类

    万次阅读 2015-12-29 14:51:25
    AES加密工具类,其中导入的jar包jdk引进去就可以用了,jdk的版本尽量大于1.5 package com.yiyong.mavenspring.demo.util; /** * @Title: AESUtil.java * @Package com.yiyong.mavenspring.demo.util * @...
  • AES加密工具类AESUtil

    千次阅读 2020-10-15 14:32:45
    本文工具类针对的是Java环境下, AES对称加密工具类, 包括加密和解密 package com.alicom.flow.util; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; import org.apache.commons.codec...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,407
精华内容 10,562
关键字:

aes256加密工具类