精华内容
下载资源
问答
  • 在对接java开发的加密方法,整理的PHP 对接java AES/ECB/PKCS7Padding加密转16进制字符串,加解密方法
  • Java AES128加密解密

    2019-01-19 20:53:59
    Java AES128加密解密 示例源码(AES-ECB-PKCS7Padding)
  • 主要介绍了Java AES256加密解密示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • AES加密的两种方式。一种String 一种byte。并且添加进制转换解决加密过程非法报错问题
  • 工作中有时需要对文件word/mp4/等等文件加密,或者文本加密
  • java aes128/256 对称加密解密,rsa对称加密解密验签实现,php java通用aes加密 支持任何形式的aes加密,文件,字符,字节等,内含php代码,可以与php平台实现aes加密,而且包含rsa非对称加密签名验签实现,都是对...
  • 综合网上的AES加密,把其做成一个工具类,方便加密解密的实现
  • 轻松实现 Python AESJava AES/ECB/PKCS5Padding互转
  • Java AES-128加解密demo

    2016-06-21 19:31:35
    该文件是Java以及Android上AES-128加解密的测试demo,可以用于与BLE设备的加密通信
  • java AES 解密/解密

    2020-09-26 14:25:24
    java 对数据进行AES 加密解密,给数据一定的安全性.java 自带,无需下载jar. 偏移量和 密钥自己设置.只有相同的密钥和和偏移量才能解密.
  • c++ AES 兼容 JAVA AES CBC PKCS5Padding C#

    热门讨论 2014-02-20 15:15:16
    公司有用C#写的AES代码 又有用JAVA AES CBC PKCS5Padding 加密的 但对于由JAVA AES CBC PKCS5Padding 加密的数据C++解密的资料极为稀缺 故本人找到了一些资源 同时改写了一些填充方式 使得与JAVA C#兼容 VS2010 测试...
  • c/c++与java互通 AES加密解密; 只使用基本char,数组运算实现加密算法;不依赖其它加密lib
  • C#使用IKVM 生成 java AES 密钥并实现加解密,需要引用bin目录下5个dll文件。
  • NULL 博文链接:https://renfj.iteye.com/blog/2086421
  • java AES工具类

    千次阅读 2020-03-03 18:53:39
    * 参考: https://howtodoinjava.com/security/java-aes-encryption-example/ * @author hank * @since 2020/3/3 0003 下午 18:00 */ public class AesCryptTools { private static final String CHARSET = "utf...
    package com.wjj.application.paysdk.crypt.tools;
    
    import javax.crypto.*;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.PBEKeySpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidKeyException;
    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.Arrays;
    import java.util.Base64;
    
    /**
     * AES工具类
     * 参考: https://howtodoinjava.com/security/java-aes-encryption-example/
     * @author hank
     * @since 2020/3/3 0003 下午 18:00
     */
    public class AesCryptTools {
        private static final String CHARSET = "utf-8";
    
        /**
         * 生成随机密钥
         * @param keySize 密钥大小推荐128 256
         * @return
         * @throws NoSuchAlgorithmException
         */
        public static String generateSecret(int keySize) throws NoSuchAlgorithmException {
            KeyGenerator generator = KeyGenerator.getInstance("AES");
            generator.init(keySize, new SecureRandom());
            SecretKey key = generator.generateKey();
           return byteToHexString(key.getEncoded());
        }
    
        public static String encrypt(String strToEncrypt, String secret) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
            SecretKeySpec secretKey = getKey(secret);
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            return Base64.getEncoder().encodeToString(cipher.doFinal(strToEncrypt.getBytes("UTF-8")));
        }
    
        public static String decrypt(String strToDecrypt, String secret) throws UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
                SecretKeySpec secretKey = getKey(secret);
                Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5PADDING");
                cipher.init(Cipher.DECRYPT_MODE, secretKey);
                return new String(cipher.doFinal(Base64.getDecoder().decode(strToDecrypt)));
        }
        private static SecretKeySpec getKey(String myKey) throws UnsupportedEncodingException, NoSuchAlgorithmException {
            byte[] key = myKey.getBytes(CHARSET);
            MessageDigest sha = MessageDigest.getInstance("SHA-1");
            key = sha.digest(key);
            key = Arrays.copyOf(key, 16);
            return new SecretKeySpec(key, "AES");
        }
        /**
         * byte数组转化为16进制字符串
         * @param bytes
         * @return
         */
        private static String byteToHexString(byte[] bytes){
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < bytes.length; i++) {
                String strHex=Integer.toHexString(bytes[i]);
                if(strHex.length() > 3){
                    sb.append(strHex.substring(6));
                } else {
                    if(strHex.length() < 2){
                        sb.append("0" + strHex);
                    } else {
                        sb.append(strHex);
                    }
                }
            }
            return  sb.toString();
        }
    
        public static void main(String[] args) throws NoSuchAlgorithmException, IllegalBlockSizeException, InvalidKeyException, BadPaddingException, NoSuchPaddingException, UnsupportedEncodingException {
            String key = generateSecret(256);
            String enData = encrypt("你好测试hello", key);
            System.out.println(enData);
            String deData = decrypt(enData, key);
            System.out.println(deData);
            enData = encrypt("你好测试", key);
            System.out.println(enData);
            deData = decrypt(enData, key);
            System.out.println(deData);
        }
    }
    

     

    展开全文
  • JAVAAES对称加密工具类

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

    千次阅读 2019-07-23 13:42:59
    另外,AES加密属于典型的块加密算法,其中常用的块加密的工作模式包含: ECB模式:又称电码本(ECB,Electronic Codebook Book)模式。这是最简单的块密码加密模式,加密前根据加密块大小(如AES为128位)分成若干...

    AES加密属于对称加密算法,可以使用相同的密码反向解密出来。另外,AES加密属于典型的块加密算法,其中常用的块加密的工作模式包含:

    • ECB模式:又称电码本(ECB,Electronic Codebook Book)模式。这是最简单的块密码加密模式,加密前根据加密块大小(如AES为128位)分成若干块,之后将每块使用相同的密钥单独加密,解密同理。
    • CBC模式:又称密码分组链接(CBC,Cipher-block chaining)模式。在这种加密模式中,每个密文块都依赖于它前面的所有明文块。同时,为了保证每条消息的唯一性,在第一个块中需要使用初始化向量IV。
    创建密钥
    /**生成key,作为加密和解密密钥且只有密钥相同解密加密才会成功
    	 * @return
    	 */
    	public static Key createKey() {
     
    		try {
    			// 生成key
    			KeyGenerator keyGenerator;
    			//构造密钥生成器,指定为AES算法,不区分大小写
    			keyGenerator = KeyGenerator.getInstance("AES");
    			//生成一个128位的随机源,根据传入的字节数组
    			keyGenerator.init(128);
    			//产生原始对称密钥
    			SecretKey secretKey = keyGenerator.generateKey();
    			//获得原始对称密钥的字节数组
    			byte[] keyBytes = secretKey.getEncoded();
    			// key转换,根据字节数组生成AES密钥
    			Key key = new SecretKeySpec(keyBytes, "AES");
    			return key;
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    			return null;
    		}
     
    	}
    
    
    加密过程
    
    
    
    /**加密
    	 * @param context 需要加密的明文
    	 * @param key 加密用密钥
    	 * @return
    	 */
    	public static byte[] jdkAES(String context, Key key) {
    		try {
     
    			Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
    			
    			cipher.init(cipher.ENCRYPT_MODE, key);
    			//将加密并编码后的内容解码成字节数组
    			byte[] result = cipher.doFinal(context.getBytes());
     
    			System.out.println("jdk aes:" + Base64.encode(result));
     
    			return result;
     
    		} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
    				| BadPaddingException e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    
    
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
    上图出示的即是getInstance方法的参数意义, 用于返回实现指定转换的 Cipher 对象。
    
    
    
    解密过程
    
    
    
    	/** 解密
    	 * @param result 加密后的密文byte数组
    	 * @param key 解密用密钥
    	 */
    	public static void decrypt(byte[] result, Key key) {
    		
    		Cipher cipher;
    		try {
    			
    			cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
    			//初始化密码器,第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作,第二个参数为使用的KEY
    			cipher.init(Cipher.DECRYPT_MODE, key);
    			result = cipher.doFinal(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();
    		}
     
    		System.out.println("jdk aes desrypt:" + new String(result));
    	}
    
    代码参考自:https://blog.csdn.net/solidsunshine/article/details/79505071

     

    展开全文
  • java AES 32位加密解密

    万次阅读 2020-09-25 20:13:48
    网上很多解密加密是16位的,用32位密钥加密会报java.security.InvalidKeyException: Illegal key size or default parameters异常错误,因为美国的出口限制,Sun通过权限文件(local_policy.jar、US_export_policy....

    1、常用加密32位原因

    网上很多解密加密是16位的,用32位密钥加密会报java.security.InvalidKeyException: Illegal key size or default parameters异常错误,因为美国的出口限制,Sun通过权限文件(local_policy.jar、US_export_policy.jar)做了相应限制。因此存在以下一些问题:

    • 密钥长度上不能满足需求(如:java.security.InvalidKeyException: Illegal key size or default parameters);
    • 部分算法未能支持,如MD4、SHA-224等算法;
    • API使用起来还不是很方便;
    • 一些常用的进制转换辅助工具未能提供,如Base64编码转换、十六进制编码转换等工具。

    2、解决方案

    Oracle在其官方网站上提供了无政策限制权限文件(Unlimited Strength Jurisdiction Policy Files),我们只需要将其部署在JRE环境中,就可以解决限制问题,特别注意:两个目录都要替换

    JDK8 jar包下载地址
    JDK7 jar包下载地址
    jdk8 jar包百度网盘地址提取码:f5ed

    %JDK_Home%\jre\lib\security目录下,对应覆盖local_policy.jar和US_export_policy.jar两个文件
    %JRE_Home%\lib\security目录下,也需要对应覆盖这两个文件。

    3、AES工具类

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;
    import java.util.Base64;
    
    /**
     * AES常用解密加密工具类
     * https://github.com/ourlang
     * @author 小林
     */
    public class AesUtil {
    
        /**
         * 默认的字符编码
         */
        private static final String DEFAULT_CHARSET = "utf-8";
    
        /**
         * 算法
         */
        private static String ALGORITHM = "AES";
    
    
        /**
         * 算法/模式/填充
         **/
        private static final String CipherMode = "AES/ECB/PKCS5Padding";
    
    
        /**
         * 记录日志
         **/
        private final static Logger logger = LoggerFactory.getLogger(AesUtil.class);
    
        private AesUtil() {
        }
    
        /**
         * 解密AES 32位
         *
         * @param sSrc      解密的内容
         * @param secretKey 秘钥
         * @return 解密后的明文 数据
         */
        public static String decrypt(String sSrc, String secretKey) {
    
            if (secretKey == null) {
                logger.error("需要加密的秘钥为空");
                return null;
            }
            try {
                byte[] raw = secretKey.getBytes(DEFAULT_CHARSET);
                SecretKeySpec secretKeySpec = new SecretKeySpec(raw, ALGORITHM);
                Cipher cipher = Cipher.getInstance(CipherMode);
                cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
                // 先用base64解密
                byte[] encryptedArr = Base64.getDecoder().decode(sSrc);
                byte[] original = cipher.doFinal(encryptedArr);
                return new String(original, DEFAULT_CHARSET);
            } catch (Exception ex) {
                logger.error("AES解密失败", ex);
                return null;
            }
        }
    
    
        /**
         * 加密32位
         *
         * @param sSrc 需要加密的内容
         * @param sKey 秘钥
         * @return 加密的内容
         */
        public static String encrypt(String sSrc, String sKey) {
            if (sKey == null) {
                logger.error("需要加密的秘钥为空");
                return null;
            }
            try {
                byte[] raw = sKey.getBytes(DEFAULT_CHARSET);
                SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITHM);
                Cipher cipher = Cipher.getInstance(CipherMode);
                cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
                byte[] encrypted = cipher.doFinal(sSrc.getBytes(DEFAULT_CHARSET));
    
                return Base64.getEncoder().encodeToString(encrypted);
            } catch (Exception ex) {
                logger.error("AES加密失败", ex);
                return null;
            }
        }
    
    }
    
    
    展开全文
  • Java AES加密解密

    2016-11-10 11:52:37
    Java AES加密解密,可以修改key值和偏移量
  • import org.slf4j.Logger; import org.slf4j.LoggerFactory; import javax.crypto.Cipher; import javax.crypto.NoSuchPaddingException; import javax.crypto.spec....import java.security.KeyPairGenerator; imp..
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.crypto.Cipher;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.util.ArrayList;
    import java.util.Base64;
    import java.util.Random;
    
    /**
     * AES加密工具类
     */
    public class AESUtil {
    
    
        /**
         * 加密Key 需要16位 可用数字与字母组成
         */
        private static String key = "Ijasw2o93jd81kdD";
        /**
         * 偏移量 需要16位
         */
        private static String iv = "4w2Df1xSj5ff662d";
    
        private static Logger log = LoggerFactory.getLogger(AESUtil.class);
    
        private static Base64.Decoder decoder;
    
        private static Base64.Encoder encoder;
    
    
    
        static {
            decoder = Base64.getDecoder();
            encoder = Base64.getEncoder();
        }
    
    
    
        public static String getSixteenBitString(){
            StringBuffer sb = new StringBuffer();
            String[] chars = new String[]{
                    "1","2","3","4","5","6","7","8","9","a","b",
                    "c","d","e","f","g","h","i","j","k","l","m",
                    "n","o","p","q","r","s","t","u","v","w","x",
                    "y","z","A","B","C","D","E","F","G","H","I",
                    "J","K","L","M","N","O","P","Q","R","S","T",
                    "U","V","W","X","Y","Z",
            };
            int len = chars.length;
            Random random = new Random();
            for (int i = 0; i < 16; i++) {
                sb.append(chars[random.nextInt(len-1)]);
            }
            return sb.toString();
    
        }
    
    
    
        /**
         * AES加密
         * @param data
         * @param key
         * @param iv
         * @return
         * @throws Exception
         */
        public static String encryptAES_CBC(String data,String key,String iv) {
            Cipher cipher = null;
            try {
                cipher = Cipher.getInstance("AES/CBC/NoPadding");
    
                int blockSize = cipher.getBlockSize();
                byte[] dataBytes = data.getBytes();
                int dataLength = dataBytes.length;
                if (dataLength % blockSize != 0) {
                    dataLength = dataLength + (blockSize - (dataLength % blockSize));
                }
                byte[] plaintext = new byte[dataLength];
                System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);
                SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "AES");
                IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes());
                cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
                byte[] bytes = cipher.doFinal(plaintext);
                return encoder.encodeToString(bytes);
    
            }catch (Exception e) {
                log.error("AES加密失败");
                log.error(e.getMessage());
    
            }
    
            return null;
    
        }
        /**
         * AES解密
         * @param data
         * @param key
         * @param iv
         * @return
         * @throws Exception
         */
        public static String decrptyAES_CBC(String data,String key,String iv){
            try {
                byte[] bytes = decoder.decode(data);
                Cipher cipher = Cipher.getInstance("AES/CBC/NoPadding");
                SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(), "AES");
                IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes());
                cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
                byte[] plainByte = cipher.doFinal(bytes);
                return new String(plainByte).trim();
            }catch (Exception e){
                log.error("AES解密失败");
                log.error(e.getMessage());
            }
    
            return null;
        }
    
    
        /**
         * AES加密
         * @param data
         * @return
         * @throws Exception
         */
        public static String encryptAES_ECB(String data,String key) throws Exception{
            Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
            int blockSize = cipher.getBlockSize();
            byte[] dataBytes = data.getBytes();
            int dataLength = dataBytes.length;
            if(dataLength % blockSize != 0){
                dataLength = dataLength + (blockSize - (dataLength % blockSize));
            }
            byte [] plaintext = new byte[dataLength];
            System.arraycopy(dataBytes,0,plaintext,0,dataBytes.length);
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(),"AES");
            cipher.init(Cipher.ENCRYPT_MODE,secretKey);
            byte[] bytes = cipher.doFinal(plaintext);
            return encoder.encodeToString(bytes);
    
    
        }
    
        /**
         * AES解密
         * @param data
         * @return
         * @throws Exception
         */
        public static String decrptyAES_ECB(String data,String key) throws Exception{
            byte[] bytes = decoder.decode(data);
            Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
            SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(),"AES");
            cipher.init(Cipher.DECRYPT_MODE,secretKey);
            byte[] plainByte = cipher.doFinal(bytes);
            return new String(plainByte).trim();
        }
    
    
    
        public static void main(String[] args) throws Exception{
            String s = "123231312";
            String encrypt = encryptAES_ECB(s,key);
            System.out.println(encrypt);
            System.out.println(decrptyAES_ECB(encrypt,key));
            String s1 = encryptAES_CBC(s, key, iv);
            System.out.println(s1);
            System.out.println(decrptyAES_CBC(s1,key,iv));
            getSixteenBitString();
        }
    
    
    
    }
    

    展开全文
  • IOS JAVA AES128加密解密

    2016-04-07 11:54:59
    IOS JAVA AES128加密解密,使用于IOS,ANDROID,JAVA
  • JAVA AES加密方式(AES-128-CBC)

    千次阅读 2021-11-15 22:45:53
    其次,AES-128-CBC模式加密,要求密钥key和偏移量IV的长度要一致,且长度都是16才可以加密。 中间进行加密。 最后,为了提高安全性,可以再进行一次base64编码。 package utils; import javax.crypto.Cipher; ...
  • Java AES加密实例

    2018-05-16 18:26:02
    java AES加密实例: }public void getKey(){ for (int i = 0; i &lt; 2; i++) { try { String str = "chris1234567";/*定义一个字符串*/ byte[] code = str.getBytes();/*把字符串转...
  • Java AES 256位加密解密

    千次阅读 2019-05-27 14:38:09
    Java AES解密加密算法默认是支持128位的,但是,最近,做了登录练习,是从数据库里的用户表提取用户账号和密码来进行验证登录,因为用户表里的密码是经过256位加密进行储存的,而且是用PKCS7Padding的填充方式来存储...
  • java Aes.java

    2021-02-24 11:13:18
    java AES加密传输
  • java编写的AES加密解密,并且包含界面
  • JAVA AES加密解密

    2015-07-30 20:45:51
    * 编码工具类 * 1.将byte[]转为各种进制的字符串 * 2.base 64 encode * 3.base 64 decode * 4.... * 5.... * 6.... * 7.AES加密 * 8.AES加密为base 64 code * 9.AES解密 * 10.将base 64 code AES解密
  • Java AES数据加密实例详解

    千次阅读 2019-02-21 19:55:49
    package ... import java.io.IOException; import java.io.UnsupportedEncodingException; import java.security.InvalidKeyException; import java.security.NoSuchAlgorithmExcep...
  • Java AES加密

    2013-08-11 20:05:14
    该资源是java或在Android中实现aes加密的代码,是测试过的,另外还有ios端的代码,随后附上。
  • JAVA AES 加密算法

    2020-08-29 17:17:53
    JAVA AES 加密算法 javax.crypto.Cipher AES/ECB/PKCS5Padding

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,946
精华内容 13,978
关键字:

javaaes

java 订阅