精华内容
下载资源
问答
  • AES加密工具类

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

    2021-07-23 14:02:25
    AES 加密工具类 import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.util.logging.Level; import java.util.logging.Logger; import javax.crypto.Cipher; import ...

    AES 加密工具类

    RSA与AES的区别

    AES:对称加密,密钥最长只有256个bit,执行速度快,易于硬件实现。由于是对称加密,密钥需要在传输前通讯双方获知。基于以上特点,通常使用RSA来首先传输AES的密钥给对方,然后再使用AES来进行加密通讯。

    RSA:非对称加密,公钥加密,私钥解密,反之亦然。由于需要大数的乘幂求模等算法,运行速度慢,不易于硬件实现。通常私钥长度有512bit,1024bit,2048bit,4096bit,长度越长,越安全,但是生成密钥越慢,加解密也越耗时。既然是加密,那肯定是不希望别人知道我的消息,所以只有我才能解密,所以可得出公钥负责加密,私钥负责解密;同理,既然是签名,那肯定是不希望有人冒充我发消息,只有我才能发布这个签名,所以可得出私钥负责签名,公钥负责验证。

    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import org.apache.commons.codec.binary.Base64;
    
    /**
     * @version V1.0
     * @desc AES 加密工具类
     */
    public class AESUtil {
    
        private static final String KEY_ALGORITHM = "AES";
        private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
    
        /**
         * AES 加密操作
         *
         * @param content 待加密内容
         * @param password 加密密码
         * @return 返回Base64转码后的加密数据
         */
        public static String encrypt(String content, String password) {
            try {
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
    
                byte[] byteContent = content.getBytes("utf-8");
    
                cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(password));// 初始化为加密模式的密码器
    
                byte[] result = cipher.doFinal(byteContent);// 加密
    
                return Base64.encodeBase64String(result);//通过Base64转码返回
            } catch (Exception ex) {
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
    
            return null;
        }
    
        /**
         * AES 解密操作
         *
         * @param content
         * @param password
         * @return
         */
        public static String decrypt(String content, String password) {
    
            try {
                //实例化
                Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
    
                //使用密钥初始化,设置为解密模式
                cipher.init(Cipher.DECRYPT_MODE, getSecretKey(password));
    
                byte[] decodeBase64 = Base64.decodeBase64(content);
                //执行操作
                byte[] result = cipher.doFinal(decodeBase64);
    
                return new String(result, "utf-8");
            } catch (Exception ex) {
                Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
            
            return null;
        }
    
        /**
         * 生成加密秘钥
         *
         * @return
         */
        private static SecretKeySpec getSecretKey(final String password) {
            //返回生成指定算法密钥生成器的 KeyGenerator 对象
            KeyGenerator kg = null;
    
            try {
                // 如果用new SecureRandom() 在服务器上会报错
                SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
                secureRandom.setSeed(password.getBytes());
                
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
    
                //AES 要求密钥长度为 128
                kg.init(128, secureRandom);
    
                //生成一个密钥
                SecretKey secretKey = kg.generateKey();
    
                return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
            } catch (NoSuchAlgorithmException ex) {  Logger.getLogger(AESUtil.class.getName()).log(Level.SEVERE, null, ex);
            }
            return null;
        }
    }
    
    
    展开全文
  • aes加密工具类

    2018-04-16 10:00:42
    用java编写的aes加密工具,内置加密、解密、测试的方法。
  • 1、AES加密工具类 java不支持PKCS7Padding,只支持PKCS5Padding。我们知道加密算法由算法+模式+填充组成,下一篇介绍iOS和Android通用的AES加密,本篇文章使用PKCS5Padding加密方式。 package com.example.aesdemo;...
  • android AES加密工具类

    2016-07-20 11:14:02
    android 可以使用的 AES加密工具类
  • Base64+ AES加密工具类 对称加密,十分的方便使用。可用于登录注册各种对称加密
  • RSA+AES 加密工具类 Java

    2018-03-13 09:53:45
    适用于Android、Java、Web端使用的AES、RSA加密工具类
  • 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加密工具类,其中导入的jar包jdk引进去就可以用了,jdk的版本尽量大于1.5

    package com.g.mavenspring.demo.util;
    /**   
     * @Title: AESUtil.java 
     * @Package com.g.mavenspring.demo.util 
     * @Description: TODO(用一句话描述该文件做什么) 
     * @author 
     * @date 2015年12月29日 下午2:38:00 
     * @version V1.0   
     */
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    public class AESUtil {
    
    	public static void main(String[] args) {
    		// 密钥的种子,可以是任何形式,本质是字节数组
    				String strKey = "aaaa";
    				// 密钥数据
    				byte[] rawKey = getRawKey(strKey.getBytes());
    				// 密码的明文
    				String clearPwd = "My world is full of wonders! No body can match my spirit";
    				// 密码加密后的密文
    				byte[] encryptedByteArr = encrypt(rawKey, clearPwd);
    				String encryptedPwd = new String(encryptedByteArr);
    				System.out.println(encryptedPwd);
    				// 解密后的字符串
    				String decryptedPwd = decrypt(encryptedByteArr, rawKey);
    				System.out.println(decryptedPwd);
    
    	}
    
    	/**
    	 * @param rawKey
    	 *            密钥
    	 * @param clearPwd
    	 *            明文字符串
    	 * @return 密文字节数组
    	 */
    	private static byte[] encrypt(byte[] rawKey, String clearPwd) {
    		try {
    			SecretKeySpec secretKeySpec = new SecretKeySpec(rawKey, "AES");
    			Cipher cipher = Cipher.getInstance("AES");
    			cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
    			byte[] encypted = cipher.doFinal(clearPwd.getBytes());
    			return encypted;
    		} catch (Exception e) {
    			return null;
    		}
    	}
    
    	/**
    	 * @param encrypted
    	 *            密文字节数组
    	 * @param rawKey
    	 *            密钥
    	 * @return 解密后的字符串
    	 */
    	private static String decrypt(byte[] encrypted, byte[] rawKey) {
    		try {
    			SecretKeySpec secretKeySpec = new SecretKeySpec(rawKey, "AES");
    			Cipher cipher = Cipher.getInstance("AES");
    			cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
    			byte[] decrypted = cipher.doFinal(encrypted);
    			return new String(decrypted);
    		} catch (Exception e) {
    			return "";
    		}
    	}
    
    	/**
    	 * @param seed种子数据
    	 * @return 密钥数据
    	 */
    	private static byte[] getRawKey(byte[] seed) {
    		byte[] rawKey = null;
    		try {
    			KeyGenerator kgen = KeyGenerator.getInstance("AES");
    			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
    			secureRandom.setSeed(seed);
    			// AES加密数据块分组长度必须为128比特,密钥长度可以是128比特、192比特、256比特中的任意一个
    			kgen.init(128, secureRandom);
    			SecretKey secretKey = kgen.generateKey();
    			rawKey = secretKey.getEncoded();
    		} catch (NoSuchAlgorithmException e) {
    		}
    		return rawKey;
    	}
    }


    展开全文
  • Android AES加密工具类

    千次阅读 2014-11-24 00:56:53
    1、AES加密工具类 java不支持PKCS7Padding,只支持PKCS5Padding。我们知道加密算法由算法+模式+填充组成,,本篇文章使用PKCS5Padding加密方式。 ''

    1、AES加密工具类

    java不支持PKCS7Padding,只支持PKCS5Padding。我们知道加密算法由算法+模式+填充组成,,本篇文章使用PKCS5Padding加密方式。

    ''


    package com.example.aesdemo;
     
    import java.io.UnsupportedEncodingException;
    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;
      
    ///** AES对称加密解密类 **/
    public class AESHelper {
      
     // /** 算法/模式/填充 **/
     private static final String CipherMode = "AES/ECB/PKCS5Padding";
      
     ///** 创建密钥 **/
     private static SecretKeySpec createKey(String password) {
     byte[] data = null;
     if (password == null) {
      password = "";
     }
     StringBuffer sb = new StringBuffer(32);
     sb.append(password);
     while (sb.length() < 32) {
      sb.append("0");
     }
     if (sb.length() > 32) {
      sb.setLength(32);
     }
      
     try {
      data = sb.toString().getBytes("UTF-8");
     } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
     }
     return new SecretKeySpec(data, "AES");
     }
      
     // /** 加密字节数据 **/
     public static byte[] encrypt(byte[] content, String password) {
     try {
      SecretKeySpec key = createKey(password);
      System.out.println(key);
      Cipher cipher = Cipher.getInstance(CipherMode);
      cipher.init(Cipher.ENCRYPT_MODE, key);
      byte[] result = cipher.doFinal(content);
      return result;
     } catch (Exception e) {
      e.printStackTrace();
     }
     return null;
     }
      
     ///** 加密(结果为16进制字符串) **/
     public static String encrypt(String content, String password) {
     byte[] data = null;
     try {
      data = content.getBytes("UTF-8");
     } catch (Exception e) {
      e.printStackTrace();
     }
     data = encrypt(data, password);
     String result = byte2hex(data);
     return result;
     }
      
     // /** 解密字节数组 **/
     public static byte[] decrypt(byte[] content, String password) {
     try {
      SecretKeySpec key = createKey(password);
      Cipher cipher = Cipher.getInstance(CipherMode);
      cipher.init(Cipher.DECRYPT_MODE, key);
      byte[] result = cipher.doFinal(content);
      return result;
     } catch (Exception e) {
      e.printStackTrace();
     }
     return null;
     }
      
     ///** 解密16进制的字符串为字符串 **/
     public static String decrypt(String content, String password) {
     byte[] data = null;
     try {
      data = hex2byte(content);
     } catch (Exception e) {
      e.printStackTrace();
     }
     data = decrypt(data, password);
     if (data == null)
      return null;
     String result = null;
     try {
      result = new String(data, "UTF-8");
     } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
     }
     return result;
     }
      
     // /** 字节数组转成16进制字符串 **/
     public static String byte2hex(byte[] b) { // 一个字节的数,
     StringBuffer sb = new StringBuffer(b.length * 2);
     String tmp = "";
     for (int n = 0; n < b.length; n++) {
      // 整数转成十六进制表示
      tmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
      if (tmp.length() == 1) {
      sb.append("0");
      }
      sb.append(tmp);
     }
     return sb.toString().toUpperCase(); // 转成大写
     }
      
     // /** 将hex字符串转换成字节数组 **/
     private static byte[] hex2byte(String inputString) {
     if (inputString == null || inputString.length() < 2) {
      return new byte[0];
     }
     inputString = inputString.toLowerCase();
     int l = inputString.length() / 2;
     byte[] result = new byte[l];
     for (int i = 0; i < l; ++i) {
      String tmp = inputString.substring(2 * i, 2 * i + 2);
      result[i] = (byte) (Integer.parseInt(tmp, 16) & 0xFF);
     }
     return result;
     }
    }

    使用~~~~~~~~~~~~~~~~··

         String masterPassword = "a"; 
         String originalText = "于"; 
     
         try { 
          String encryptingCode = AESHelper.encrypt(originalText,masterPassword); 
    //    System.out.println("加密结果为 " + encryptingCode); 
          Log.i("加密结果为 ",encryptingCode); 
          String decryptingCode = AESHelper.decrypt(encryptingCode,masterPassword); 
    //    System.out.println("解密结果为 " + decryptingCode); 
          Log.i("解密结果",decryptingCode); 
          } catch (Exception e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
         }  
        }

    结果

    加密结果为(707): E55C24701F6380478E1940ADDFD08D22

    解密结果( 707 ): 于

    展开全文
  • 直播系统定制,AES加密工具类封装的相关代码 import android.util.Base64; import java.security.MessageDigest; import java.security.spec.AlgorithmParameterSpec; import javax.crypto.Cipher; import javax....

    直播系统定制,AES加密工具类封装的相关代码

    import android.util.Base64;
    
    import java.security.MessageDigest;
    import java.security.spec.AlgorithmParameterSpec;
    
    import javax.crypto.Cipher;
    import javax.crypto.spec.IvParameterSpec;
    import javax.crypto.spec.SecretKeySpec;
    
    public class AES64 {
    
       private final Cipher cipher;
       private final SecretKeySpec key;
       private AlgorithmParameterSpec spec;
       // 密钥
       public static final String SEED_16_CHARACTER = "更换成自己的密钥";
    
       public AES64() throws Exception {
          // hash password with SHA-256 and crop the output to 128-bit for key
          MessageDigest digest = MessageDigest.getInstance("SHA-256");//AES-256-CBC
          digest.update(SEED_16_CHARACTER.getBytes("UTF-8"));
          byte[] keyBytes = new byte[32];
          System.arraycopy(digest.digest(), 0, keyBytes, 0, keyBytes.length);
          cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");
          key = new SecretKeySpec(keyBytes, "AES");
          spec = getIV();
       }
    
       public AlgorithmParameterSpec getIV() {
          byte[] iv = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
          IvParameterSpec ivParameterSpec;
          ivParameterSpec = new IvParameterSpec(iv);
          return ivParameterSpec;
       }
    
       /**
        * 加密
        * @param plainText
        * @return
        * @throws Exception
        */
       public String encrypt(String plainText) throws Exception {
          cipher.init(Cipher.ENCRYPT_MODE, key, spec);
          byte[] encrypted = cipher.doFinal(plainText.trim().getBytes("UTF-8"));
          String encryptedText = new String(Base64.encode(encrypted,
                Base64.DEFAULT), "UTF-8");
          encryptedText = encryptedText.replace("\n", "");
          return encryptedText;
       }
    
       /**
        * 解密
        * @param cryptedText
        * @return
        * @throws Exception
        */
       public String decrypt(String cryptedText) throws Exception {
          cipher.init(Cipher.DECRYPT_MODE, key, spec);
          byte[] bytes = Base64.decode(cryptedText, Base64.DEFAULT);
          byte[] decrypted = cipher.doFinal(bytes);
          String decryptedText = new String(decrypted, "UTF-8");
          return decryptedText;
       }
    
    }
    

    以上就是直播系统定制,AES加密工具类封装的相关代码, 更多内容欢迎关注之后的文章

    展开全文
  • aes加密解密工具类,解决在linux服务加密解密异常问题。
  • 封装POST请求和 AES加密解密的代码,可以作为工具类直接引用,封装POST请求和 AES加密解密的代码,可以作为工具类直接引用
  • 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...
  • ### 创建AES加密工具类方法(crypto) 第一步: //安装 npm install crypto-js --save-dev 第二步: 在src文件夹中创建crypto.js 第三步:crypto.js import CryptoJS from 'crypto-js' // 加密 export default { ...
  • AES加密工具类封装

    2020-07-16 16:08:53
    import android.util.Base64; import java.security.MessageDigest; import java.security.spec.AlgorithmParameterSpec; import javax.crypto.Cipher; import javax.crypto.spec....public class AES64 { pri.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,025
精华内容 6,010
关键字:

aes加密工具类