精华内容
下载资源
问答
  • aes加密算法java实现
    2021-05-28 14:34:47

    项目中需要用到AES算法加密,写了个可用的工具类,做一下记录。

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.spec.SecretKeySpec;
    
    public class AESUtils {
    
        private static final Logger logger = LoggerFactory.getLogger(AESUtils.class);
    
        // 默认全部使用ECB模式的对称加密(主要是因为ECB模块适合并行计算)
        private static final String ALGORITHM_PADDING = "AES/ECB/PKCS5Padding";
        private static final String ALGORITHM_NAME = "AES";
        private static KeyGenerator sKeyGen;
    
        static {
            try {
                sKeyGen = KeyGenerator.getInstance(ALGORITHM_NAME);
                sKeyGen.init(128);
            } catch (Exception e) {
                logger.error("AES init exception:", e);
            }
        }
    
        /**
         * 加密方法
         *
         * @param content
         * @param password
         * @return
         */
        private static byte[] encrypt(String content, byte[] password) {
            try {
                SecretKeySpec key = new SecretKeySpec(password, ALGORITHM_NAME);
                Cipher cipher = Cipher.getInstance(ALGORITHM_PADDING);
                byte[] byteContent = content.getBytes("utf-8");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                return cipher.doFinal(byteContent);
            } catch (Exception e) {
                logger.error("AES encrypt exception:", e);
            }
            return null;
        }
    
        /**
         * 解密方法
         *
         * @param content
         * @param password
         * @return
         */
        private static byte[] decrypt(byte[] content, byte[] password) {
            try {
                SecretKeySpec key = new SecretKeySpec(password, ALGORITHM_NAME);
                Cipher cipher = Cipher.getInstance(ALGORITHM_PADDING);
                cipher.init(Cipher.DECRYPT_MODE, key);
                return cipher.doFinal(content);
            } catch (Exception e) {
                logger.error("AES decrypt exception:", e);
            }
            return null;
        }
    
        /**
         * 字符串转换为二进制字节数组
         *
         * @param hexStr
         * @return
         */
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr == null || hexStr.length() < 1) {
                return null;
            }
            byte[] result = new byte[hexStr.length() / 2];
            for (int i = 0; i < hexStr.length() / 2; i++) {
                int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
                int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
                        16);
                result[i] = (byte) (high * 16 + low);
            }
            return result;
        }
    
        /**
         * 二进制字节数组转换为字符串
         *
         * @param bytes
         * @return
         */
        public static String byteArray2HexString(byte[] bytes) {
            if (null == bytes) {
                return "";
            }
            StringBuilder hexString = new StringBuilder();
            for (byte b : bytes) {
                String str = Integer.toHexString(0xFF & b);
                while (str.length() < 2) {
                    str = "0" + str;
                }
                hexString.append(str);
            }
            return hexString.toString();
        }
    
        /**
         * 加密主方法
         *
         * @param content
         * @param key
         * @return
         */
        public static String encode(String content, byte[] key) {
            return byteArray2HexString(encrypt(content, key));
        }
    
        /**
         * 解密主方法
         *
         * @param content
         * @param key
         * @return
         */
        public static String decode(String content, byte[] key) {
            byte[] b = decrypt(parseHexStr2Byte(content), key);
            return new String(b);
        }
    }
    

    使用的时候,加密直接调用encode方法,解密的时候调用decode方法。

    更多相关内容
  • 北京交通大学密码学作业,第三次实验源码及实验报告,包括工程文件和测试用例
  • AES加密算法java实现

    热门讨论 2015-01-15 16:32:38
    AES高级加密标准,在密码学中又称Rijndael加密法,是美国联邦政府采用的一种...本软件是用java语言开发,实现AES算法对文件的加密和解密,并在界面上加了进度条,来提示用户加密解密的进度。如果不足之处,欢迎留言。
  • 1. AES 1.1. 概念 密码学中的高级加密标准(Advanced Encryption Standard,AES),又称Rijndael加密法,是美国联邦政府采用的一种区块...1.2. JAVA实现AES加解密 import lombok.extern.slf4j.Slf4j; import javax.

    1. AES

    1.1. 概念

    密码学中的高级加密标准(Advanced Encryption Standard,AES),又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。
    这个标准用来替代原先的DES(Data Encryption Standard),已经被多方分析且广为全世界所使用,已然成为对称密钥加密中最流行的算法之一。详见 百科 高级加密标准 AES

    1.2. JAVA实现AES加解密

    import lombok.extern.slf4j.Slf4j;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.security.SecureRandom;
    import java.util.Arrays;
    
    @Slf4j
    class AESCryptoUtil {
        public static void main(String[] args) {
            String content = "美好的世界,美好的中国,美好的未来!!!";
    
            byte[] encryptResult = encrypt(content);
            byte[] decryptResult = decrypt(encryptResult);
    
    
            String encryptStr = parseByte2HexStr(encryptResult);
            printMsg("========\n加密前:%s\n加密后:%s\n解密后:%s", content, encryptStr, new String(decryptResult));
    
            //解密时,不能new String(encryptResult,"utf-8").getBytes("utf-8")
            decryptResult = decrypt(parseHexStr2Byte(encryptStr));
            printMsg("========\n加密前:%s\n加密后:%s\n解密后:%s", content, encryptStr,new String(decryptResult));
    
    
            //采用AES/ECB/NoPadding时,要求密钥长度16、24、32中的一个、待加密内容的byte[]长度必须是16的倍数
            encryptResult = encrypt2(content);
            decryptResult = decrypt2(encryptResult);
            encryptStr = parseByte2HexStr(encryptResult);
            printMsg("========\n加密前:%s\n加密后:%s\n解密后:%s", content, encryptStr, new String(decryptResult));
    
        }
    
        private static void printMsg(String template, Object... args) {
            System.out.println(String.format(template, args));
        }
    
        private static String password = "科技兴国@!##";
        private static SecretKeySpec key;
    
        static {
            init();
        }
    
        private static void init() {
            try {
                KeyGenerator kgen = KeyGenerator.getInstance("AES");
                kgen.init(256, new SecureRandom(password.getBytes()));
                SecretKey secretKey = kgen.generateKey();
                byte[] enCodeFormat = secretKey.getEncoded();
                key = new SecretKeySpec(enCodeFormat, "AES");
            } catch (Exception e) {
                log.error("初始化AES算法失败" + e.getMessage(), e);
            }
        }
    
        /**
         * 加密
         *
         * @param content 需要加密的内容
         * @return
         */
        public static byte[] encrypt(String content) {
            try {
                Cipher cipher = Cipher.getInstance("AES");
                byte[] byteContent = content.getBytes("utf-8");
                cipher.init(Cipher.ENCRYPT_MODE, key);
                byte[] result = cipher.doFinal(byteContent);
                return result;
            } catch (Exception e) {
                log.error("AES加密失败" + e.getMessage(), e);
            }
            return null;
        }
    
        public static byte[] decrypt(byte[] content) {
            try {
                Cipher cipher = Cipher.getInstance("AES");
                cipher.init(Cipher.DECRYPT_MODE, key);
                byte[] result = cipher.doFinal(content);
                return result;
            } catch (Exception e) {
                log.error("AES解密失败" + e.getMessage(), e);
            }
            return null;
        }
    
        /**
         * 加密
         *
         * @param content 需要加密的内容
         * @return
         */
        public static byte[] encrypt2(String content) {
            try {
                byte[] bytePassword = password.getBytes();
                bytePassword = checkByteLength(bytePassword);
                SecretKeySpec key = new SecretKeySpec(bytePassword, "AES");
                Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
                byte[] byteContent = content.getBytes("utf-8");
                byteContent = checkByteLength(byteContent);
                cipher.init(Cipher.ENCRYPT_MODE, key);
                byte[] result = cipher.doFinal(byteContent);
                return result;
            } catch (Exception e) {
                log.error("AES加密失败" + e.getMessage(), e);
            }
            return null;
        }
    
        public static byte[] decrypt2(byte[] content) {
            try {
                byte[] bytePassword = password.getBytes();
                bytePassword = checkByteLength(bytePassword);
                SecretKeySpec key = new SecretKeySpec(bytePassword, "AES");
                Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
                cipher.init(Cipher.DECRYPT_MODE, key);
                byte[] result = cipher.doFinal(content);
                return result;
            } catch (Exception e) {
                log.error("AES解密失败" + e.getMessage(), e);
            }
            return null;
        }
    
        private static byte[] checkByteLength(byte[] byteContent) {
            int length = byteContent.length;
            int remainder = length % 16;
            if(remainder == 0){
                return byteContent;
            }else{
                return Arrays.copyOf(byteContent,length+(16-remainder));
            }
        }
    
        /**将二进制转换成16进制
         * @param buf
         * @return
         */
        public 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();
        }
    
        public static byte[] parseHexStr2Byte(String hexStr) {
            if (hexStr.length() < 1) {
                return null;
            }
            byte[] result = new byte[hexStr.length()/2];
            for (int i = 0;i< hexStr.length()/2; i++) {
                int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);
                int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);
                result[i] = (byte) (high * 16 + low);
            }
            return result;
        }
    }
    

    2. 使用中的各种坑

    2.1. 加密后的byte数组不能强制转换成字符串

    加密后返回byte[],此byte数组强制转换为字符串是乱码,然后再用转换后的字符串转换为byte数组去解码(见下面的代码)会报错:Input length must be multiple of 16 when decrypting with padded cipher

    在这种情况下: 字符串和byte数组不是互逆的;要避免这种情况,需要做一些修订,可以考虑将二进制数据转换成十六进制表示。详见parseByte2HexStr、parseHexStr2Byte两个方法

    decryptResult = decrypt(new String(encryptResult,"utf-8").getBytes("utf-8"));
    

    2021-07-02 11:27:39.067 [main] ERROR pattern.chain.AESCryptoUtil:decrypt:87 - AES解密失败Input length must be multiple of 16 when decrypting with padded cipher
    javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher
    at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:936) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:847) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.AESCipher.engineDoFinal(AESCipher.java:446) ~[sunjce_provider.jar:1.8.0_171]
    at javax.crypto.Cipher.doFinal(Cipher.java:2164) ~[?:1.8.0_171]
    at org.apache.design.pattern.chain.AESCryptoUtil.decrypt(AESCryptoUtil.java:84) [classes/:?]
    at org.apache.design.pattern.chain.AESCryptoUtil.main(AESCryptoUtil.java:26) [classes/:?]

    2.2. 采用AES/ECB/NoPadding加密的限制

    当采用如下方式获取Cipher实例时,则要求密钥长度16、24、32中的一个、待加密内容的byte[]长度必须是16的倍数,否则报如下错误:

    Cipher cipher = Cipher.getInstance("AES/ECB/NoPadding");
    

    2021-07-02 11:37:15.432 [main] ERROR pattern.chain.AESCryptoUtil:encrypt2:111 - AES加密失败Input length not multiple of 16 bytes
    javax.crypto.IllegalBlockSizeException: Input length not multiple of 16 bytes
    at com.sun.crypto.provider.CipherCore.finalNoPadding(CipherCore.java:1042) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:1010) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.CipherCore.doFinal(CipherCore.java:847) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.AESCipher.engineDoFinal(AESCipher.java:446) ~[sunjce_provider.jar:1.8.0_171]
    at javax.crypto.Cipher.doFinal(Cipher.java:2164) ~[?:1.8.0_171]


    2021-07-02 11:36:39.064 [main] ERROR pattern.chain.AESCryptoUtil:encrypt2:111 - AES加密失败Invalid AES key length: 18 bytes
    java.security.InvalidKeyException: Invalid AES key length: 18 bytes
    at com.sun.crypto.provider.AESCrypt.init(AESCrypt.java:87) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.ElectronicCodeBook.init(ElectronicCodeBook.java:94) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.CipherCore.init(CipherCore.java:592) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.CipherCore.init(CipherCore.java:468) ~[sunjce_provider.jar:1.8.0_171]
    at com.sun.crypto.provider.AESCipher.engineInit(AESCipher.java:313) ~[sunjce_provider.jar:1.8.0_171]
    at javax.crypto.Cipher.implInit(Cipher.java:801) ~[?:1.8.0_171]
    at javax.crypto.Cipher.chooseProvider(Cipher.java:863) ~[?:1.8.0_171]

    2.3 美国的出口管制限制引起的坑

    2.3.1. 背景

    因为美国的出口管制限制,Java发布的运行环境包中的加解密有一定的限制。
    比如默认不允许256位密钥的AES加解密,如果使用,会报如下错误:
    2021-07-02 11:40:34.048 [main] ERROR pattern.chain.AESCryptoUtil:encrypt:75 - AES加密失败Illegal key size or default parameters
    java.security.InvalidKeyException: Illegal key size or default parameters
    at javax.crypto.Cipher.checkCryptoPerm(Cipher.java:1025) ~[?:1.8.0_171]
    at javax.crypto.Cipher.implInit(Cipher.java:800) ~[?:1.8.0_171]
    at javax.crypto.Cipher.chooseProvider(Cipher.java:863) ~[?:1.8.0_171]
    at javax.crypto.Cipher.init(Cipher.java:1248) ~[?:1.8.0_171]
    at javax.crypto.Cipher.init(Cipher.java:1185) ~[?:1.8.0_171]

    从Java 1.8.0_151

    2.3.2. 解决方案

    方案1
    将%JDK_HOME%\jre\lib\security\java.security, 找到定义java安全性属性crypto.policy的行,将值修改为unlimited。
    默认情况下,您应该能找到一条注释掉的行:
    #crypto.policy=unlimited
    您可以通过取消注释该行来启用无限制,删除#:

    方案2
    如果%JDK_HOME%\jre\lib\security目录下有jar包 且 crypto.policy 未配置,则使用jar包内置的规则
    将%JDK_HOME%\jre\lib\security\policy\unlimited下的2个JAR【local_policy.jar、US_export_policy.jar】复制到%JDK_HOME%\jre\lib\security目录下,如果有,直接覆盖。

    方案3
    如果%JDK_HOME%\jre\lib\security目录下没有jar包 且 crypto.policy 未配置,则默认启用无限制的。

    升级版本
    https://www.oracle.com/technetwork/java/javase/8u161-relnotes-4021379.html
    在官方文档写到,
    security-libs/javax.crypto
    Unlimited cryptography enabled by default
    The JDK uses the Java Cryptography Extension (JCE) Jurisdiction Policy files to configure cryptographic algorithm restrictions. Previously, the Policy files in the JDK placed limits on various algorithms. This release ships with both the limited and unlimited jurisdiction policy files, with unlimited being the default. The behavior can be controlled via the new ‘crypto.policy’ Security property found in the /lib/java.security file. Please refer to that file for more information on this property.
    也就是从 1.8.0_161-b12 版本后,默认将采用无限制的加密算法,也就是使用 unlimited 下的jar包。我们也可以通过 设置 java.security 文件的 crypto.policy的值来改变这个默认的值。

    展开全文
  • 主要介绍了java实现AES加密算法,结合完整实例形式分析了AES加密类的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java实现AES加密算法

    2022-02-21 21:03:47
    一、AES简介 高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法。 对称加密算法:加密和解密用相同的密钥。 图解: ...用来加密明文的密码,在对称加密算法中,加密与解密...设AES加密函数为

    一、AES简介

    高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法。

    对称加密算法:加密和解密用相同的密钥。

    图解:

    介绍:

    明文 P

    没有经过加密的原始数据

    密钥 K

    用来加密明文的密码,在对称加密算法中,加密与解密的密钥是相同的,密钥为发送方与接收方协商产生,但不可以直接在网络上传输,否则会导致密钥泄露,通常是通过非对称加密算法加密密钥,然后再通过网络传输给对方,或者直接面对面商量密钥

    AES 加密函数

    设AES加密函数为E,则C = E(K,P).其中P为明文,K为密钥,C为密文。也就是说,把明文P和密钥K作为加密函数的参数输入,则加密函数E会输出密文C

    密文 C

    经过加密函数处理后的数据

    AES解密函数

    设AES解密函数为D,则P = D().其中C为密文,K为密钥,P为明文。也就是说,把密文C和密钥K作为解密函数的参数输入,则解密函数会输出明文P

    二、Java示例

    /**
     * @author qingnianren
     */
    public class Aes {
    
    
        public static final String ALGORITHM = "AES";
    
        /**
         * 生成密钥
         *
         * @return
         * @throws NoSuchAlgorithmException
         */
        public static SecretKey generateKey() throws NoSuchAlgorithmException {
            KeyGenerator secretGenerator = KeyGenerator.getInstance(ALGORITHM);
            SecureRandom secureRandom = new SecureRandom();
            secretGenerator.init(secureRandom);
            SecretKey secretKey = secretGenerator.generateKey();
            return secretKey;
        }
    
        static Charset charset = Charset.forName("UTF-8");
    
        /**
         * 加密
         *
         * @param content
         * @param secretKey
         * @return
         */
        public static byte[] encrypt(String content, SecretKey secretKey) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { // 加密
            return aes(content.getBytes(charset), Cipher.ENCRYPT_MODE, secretKey);
        }
    
        /**
         * 解密
         *
         * @param contentArray
         * @param secretKey
         * @return
         */
        public static String decrypt(byte[] contentArray, SecretKey secretKey) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException { // 解密
            byte[] result = aes(contentArray, Cipher.DECRYPT_MODE, secretKey);
            return new String(result, charset);
        }
    
        private static byte[] aes(byte[] contentArray, int mode, SecretKey secretKey)
                throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(mode, secretKey);
            byte[] result = cipher.doFinal(contentArray);
            return result;
        }
    
        public static void main(String[] args) {
            String content = "青年人需要认识到自己所负的责任!";
            SecretKey secretKey;
            try {
                long timeStartEncry = System.currentTimeMillis();
                // 生成密钥
                secretKey = generateKey();
    
                byte[] encryptResult = encrypt(content, secretKey);
                long timeEndEncry = System.currentTimeMillis();
                System.out.println("加密后的结果为==" + new String(encryptResult, charset));
    
                String decryptResult = decrypt(encryptResult, secretKey);
                System.out.println("解密后的结果==" + decryptResult);
    
                System.out.println("加密用时:" + (timeEndEncry - timeStartEncry));
            } catch (NoSuchAlgorithmException | InvalidKeyException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e) {
                e.printStackTrace();
            }
        }
    }
    

     

    展开全文
  • 用C语言实现的128位AES加密算法,可以运行在JAVA的JNI 中AIS加密算法c语言实现代码 nt cnt for(ent =0: cnt< 8: cnt++) BvtcToBit(*(ch+cnt), bit+(ent<<3)) return /将二进制位串转为长度为8的字符串水 ...
  • AES加密算法java实现

    2019-07-23 18:18:38
    AES加密算法是密码学中的高级加密标准,该加密算法采用对称分组密码体制,密钥长度的最少支持为128、192、256,分组长度128位,算法应易于各种硬件和软件实现。这种加密算法是美国联邦政府采用的区块加密标准,这个...

    转载自: https://blog.csdn.net/zyhlwzy/article/details/77948165

    AES加密算法是密码学中的高级加密标准,该加密算法采用对称分组密码体制,密钥长度的最少支持为128、192、256,分组长度128位,算法应易于各种硬件和软件实现。这种加密算法是美国联邦政府采用的区块加密标准,这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。

    过多原理不做解释,可以参考(AES加密算法原理http://www.jiamisoft.com/blog/858-aesjiamisuanfa.html)

    java中的具体使用如下:

    public class SecurityAESUtils {
    private static Logger logger = LogManager.getLogger(SecurityAESUtils.class);

    private static final String ENCODEING = "UTF-8";
    private static final String ALGORITHM = "AES";//加密算法
    
    private static final String CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//算法/工作模式/填充方式 
    
    /**
     * 加密
     * @param plaintext 明文
     * @param secureKey 16位长度的密钥
     * @return
     */
    public static String encrypt(String plaintext, String secureKey) throws Exception{
        SecretKeySpec sks = getSecretKeySpec(secureKey);
        Cipher encryptCipher = getCipher(Cipher.ENCRYPT_MODE, sks);
        byte[] result = encryptCipher.doFinal(plaintext.getBytes(ENCODEING));
        return  Base64.encodeBase64String(result);
    }
    
    /**
     * 加密
     * @param bytes 
     * @param secureKey 16位长度的密钥
     * @return
     */
    public static String encryptBytes(byte[] bytes, String secureKey) throws Exception{
        SecretKeySpec sks = getSecretKeySpec(secureKey);
        Cipher encryptCipher = getCipher(Cipher.ENCRYPT_MODE, sks);
        byte[] result = encryptCipher.doFinal(bytes);
        return  Base64.encodeBase64String(result);
    }
    
    /**
     * 解密
     * @param ciphertext 密文
     * @return secureKey 16位长度的密钥
     * @throws Exception
     */
    public static String decrypt(String ciphertext, String secureKey) throws Exception {
        SecretKeySpec sks = getSecretKeySpec(secureKey);
        Cipher decryptCiphe = getCipher(Cipher.DECRYPT_MODE, sks);//initDecryptCipher(secureKey);
        byte[] result =  decryptCiphe.doFinal(Base64.decodeBase64(ciphertext));
        return new String(result, ENCODEING);
    }
    
    private static Cipher getCipher(int cipherMode, SecretKeySpec sks) throws Exception{
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(cipherMode, sks);
        return cipher;
    }
    
    private static SecretKeySpec getSecretKeySpec(String secureKey) throws Exception{
        if(secureKey == null || secureKey.trim().equals("") || secureKey.length() != 16){
            throw new Exception("密钥不能为空或密钥长度不对");
        }
        byte[] raw = secureKey.getBytes(ENCODEING);
        SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITHM);
        return skeySpec;
    }
    
    /**
     * @Comment 加密不限制密码长度
     * @Author Ron
     * @Date 2017年9月12日 下午3:21:59
     * @return
     */
    public static String encryptNotLimit(String plaintext, String secureKey) throws Exception{
        SecretKeySpec sks = getSecretKeySpecByRandomSeed(secureKey);
        Cipher encryptCipher = getCipher(Cipher.ENCRYPT_MODE, sks);
        byte[] result = encryptCipher.doFinal(plaintext.getBytes(ENCODEING));
        return Hex.encodeHexString(result);
    }
    
    /**
     * @Comment 解密不限制密码长度
     * @Author Ron
     * @Date 2017年9月12日 下午3:22:30
     * @return
     */
    public static String decryptNotLimit(String ciphertext, String secureKey) throws Exception {
        SecretKeySpec sks = getSecretKeySpecByRandomSeed(secureKey);
        Cipher decryptCiphe = getCipher(Cipher.DECRYPT_MODE, sks);
        byte[] result =  decryptCiphe.doFinal(Hex.decodeHex(ciphertext.toCharArray()));
        return new String(result, ENCODEING);
    }
    
    /**
     * @Comment 构造私钥
     * @Author Ron
     * @Date 2017年9月12日 下午3:22:59
     * @return
     */
    private static SecretKeySpec getSecretKeySpecByRandomSeed(String secureKey){
        SecretKeySpec sks = null;
        try {
            KeyGenerator kgen = KeyGenerator.getInstance(ALGORITHM);
            //安全随机数生成器 
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");//使用默认的SHA1PRNG算法
            secureRandom.setSeed(secureKey.getBytes(ENCODEING));
            kgen.init(128, secureRandom); 
            SecretKey secretKey = kgen.generateKey();
            byte[] secretKeyEncoded = secretKey.getEncoded();
            sks = new SecretKeySpec(secretKeyEncoded, ALGORITHM);
        } catch (Exception e) {
            logger.error("",e);
        }
        return sks;
    }
    
    public static void main(String[] args) throws Exception {
        String key = "ron.zheng@tfscha";
        String src = "我是Ron";
        String enString = encrypt(src,key);
        System.out.println("加密后的数据:"+enString);
        System.out.println("解密后的数据:"+decrypt(enString,key));
    
        //不限制密钥长度
        String nkey = "ron.zheng@tfschang.com";
        enString = encryptNotLimit(src, nkey);
        System.out.println("加密后的数据:"+enString);
        System.out.println("解密后的数据:"+decryptNotLimit(enString,nkey));
    }
    

    }

    展开全文
  • AES加密Java实现

    2021-09-05 03:40:10
    这里写目录标题AES加密算法的详细介绍与实现128位分组加密和解密数据DEMO三级目录 AES加密算法的详细介绍与实现 ①:https://blog.csdn.net/qq_28205153/article/details/55798628 ②:...
  • 本文就简单介绍如何通过JAVA实现AES加密: /** * 测试AES加密和解密 * @param args */ public static void main(String[] args) { /**数据初始化**/ String content = "http://www.mbaike.net"; String...
  • 主要介绍了Java实现的对称加密算法AES,结合实例形式分析了对称加密算法AES的定义、特点、用法及使用场景,需要的朋友可以参考下
  • 主要介绍了Java实现AES加密算法的简单示例分享,AES算法是基于对密码值的置换和替代,需要的朋友可以参考下
  • JAVA AES 加密算法

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

    2019-12-27 18:01:03
    运行环境:Windows + eclipse + JAVA AES为分组密码,分组密码也就是把明文分成一组一组的,每组长度相等,每次加密一组数据,直到加密完整个明文。在AES标准规范中,分组长度只能是128位,也就是说,每个分组为16...
  • 使用java实现的DES算法加密,带有界面。DES加密算法JAVA实现(带简单界面)
  • AES加密算法原理 1. S-P结构加密 AES加密算法是2001年由美国提出的互联网加密算法,从密码学的角度来讲,AES是典型的S-P结构加密。什么是S-P结构加密呢,手残博主画了一张图帮助大家理解: 从这张图中可以看到,M...
  • 主要介绍了Java实现AES256加密解密功能,结合完整实例形式分析了Java实现AES256加密解密功能的步骤与相关操作技巧,需要的朋友可以参考下
  • 自己在项目开发中有需要用到AES,但都没有直接能用的,所以封装了相应的类。同时,提供我用于测试的测试工程。实际使用中,只需要使用其中的AESAlg.java文件即可,希望能帮到各位。工程运行结果如下: 密文:[B@57fa...
  • AES_Java 使用Java实现AES加密算法的完整过程
  • 如果希望进行AES256位的加密解密,需要事先从java官网下载 local_policy.jar与US_export_policy.jar替换%JAVA_HOME%/jre/lib/security的两个policy文件,local_policy.jar与US_export_policy.jar。 主要是为了突破...
  • 常用的对称加密算法有 DES、AES。 非对称加密算法(asymmetric-key cryptography):加密和解密使用不同的密钥,例如公钥加密的内容只能用私钥解密,所以又称为公钥加密算法(public-key cryptography)。使用最广泛...
  • aes html 加解密插件与js工具 AES算法实现Java和JS互通加解密AES算法实现Java和JS互通加解密
  • java和js实现aes加密解密,对重要信息进行加密传输,使得java、JavaScript、android、ios一致
  • 加密算法 对称加密算法 symmetric-key cryptography ...AES加密 Advanced Encryption Standard 高级加密标准,是一种对称加密算法,取代了DES加密算法,因为AES安全性更高 https://zhuanlan.zhihu.com/p/39601
  • 基于C语言的AES加密算法实现

    千次阅读 2021-12-04 21:14:13
    本文只说明AES算法的使用
  • JAVA实现AES加密、解密

    千次阅读 2022-04-07 11:23:21
    一、什么是AES? 高级加密标准(英语:Advanced Encryption Standard,缩写:...完善的加密算法在理论上是无法破解的,除非使用穷尽法。使用穷尽法破解密钥长度在128位以上的加密数据是不现实的,仅存在理论上的可能性
  • AES加密解密JAVA实现

    2014-02-12 14:45:41
    代码详细,有关AES加密解密算法,步骤清晰

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,233
精华内容 8,893
关键字:

aes加密算法java实现

友情链接: DVHOPS.zip