zoukankan      html  css  js  c++  java
  • AES和RSA算法的demo代码

    aes代码示例:

    package com.autoyol.util.security.test;
    import java.security.Key;
    import java.security.NoSuchAlgorithmException;
    import java.security.interfaces.RSAPublicKey;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    import org.apache.commons.codec.binary.Base64;
    
    public class AESCoder {
        /**
         * 密钥算法
         */
        private static final String KEY_ALGORITHM = "AES";
    
        private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";
    
        /**
         * 初始化密钥
         *
         * @return byte[] 密钥
         * @throws Exception
         */
        public static byte[] initSecretKey() {
            //返回生成指定算法的秘密密钥的 KeyGenerator 对象
            KeyGenerator kg = null;
            try {
                kg = KeyGenerator.getInstance(KEY_ALGORITHM);
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
                return new byte[0];
            }
            //初始化此密钥生成器,使其具有确定的密钥大小
            //AES 要求密钥长度为 128
            kg.init(128);
            //生成一个密钥
            SecretKey  secretKey = kg.generateKey();
            return secretKey.getEncoded();
        }
    
        /**
         * 转换密钥
         *
         * @param key   二进制密钥
         * @return 密钥
         */
        public static Key toKey(byte[] key){
            //生成密钥
            return new SecretKeySpec(key, KEY_ALGORITHM);
        }
    
        /**
         * 加密
         *
         * @param data  待加密数据
         * @param key   密钥
         * @return byte[]   加密数据
         * @throws Exception
         */
        public static byte[] encrypt(byte[] data,Key key) throws Exception{
            return encrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
        }
    
        /**
         * 加密
         *
         * @param data  待加密数据
         * @param key   二进制密钥
         * @return byte[]   加密数据
         * @throws Exception
         */
        public static byte[] encrypt(byte[] data,byte[] key) throws Exception{
            return encrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
        }
    
    
        /**
         * 加密
         *
         * @param data  待加密数据
         * @param key   二进制密钥
         * @param cipherAlgorithm   加密算法/工作模式/填充方式
         * @return byte[]   加密数据
         * @throws Exception
         */
        public static byte[] encrypt(byte[] data,byte[] key,String cipherAlgorithm) throws Exception{
            //还原密钥
            Key k = toKey(key);
            return encrypt(data, k, cipherAlgorithm);
        }
    
        /**
         * 加密
         *
         * @param data  待加密数据
         * @param key   密钥
         * @param cipherAlgorithm   加密算法/工作模式/填充方式
         * @return byte[]   加密数据
         * @throws Exception
         */
        public static byte[] encrypt(byte[] data,Key key,String cipherAlgorithm) throws Exception{
            //实例化
            Cipher cipher = Cipher.getInstance(cipherAlgorithm);
            //使用密钥初始化,设置为加密模式
            cipher.init(Cipher.ENCRYPT_MODE, key);
            //执行操作
            return cipher.doFinal(data);
        }
    
    
    
        /**
         * 解密
         *
         * @param data  待解密数据
         * @param key   二进制密钥
         * @return byte[]   解密数据
         * @throws Exception
         */
        public static byte[] decrypt(byte[] data,byte[] key) throws Exception{
            return decrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
        }
    
        /**
         * 解密
         *
         * @param data  待解密数据
         * @param key   密钥
         * @return byte[]   解密数据
         * @throws Exception
         */
        public static byte[] decrypt(byte[] data,Key key) throws Exception{
            return decrypt(data, key,DEFAULT_CIPHER_ALGORITHM);
        }
    
        /**
         * 解密
         *
         * @param data  待解密数据
         * @param key   二进制密钥
         * @param cipherAlgorithm   加密算法/工作模式/填充方式
         * @return byte[]   解密数据
         * @throws Exception
         */
        public static byte[] decrypt(byte[] data,byte[] key,String cipherAlgorithm) throws Exception{
            //还原密钥
            Key k = toKey(key);
            return decrypt(data, k, cipherAlgorithm);
        }
    
        /**
         * 解密
         *
         * @param data  待解密数据
         * @param key   密钥
         * @param cipherAlgorithm   加密算法/工作模式/填充方式
         * @return byte[]   解密数据
         * @throws Exception
         */
        public static byte[] decrypt(byte[] data,Key key,String cipherAlgorithm) throws Exception{
            //实例化
            Cipher cipher = Cipher.getInstance(cipherAlgorithm);
            //使用密钥初始化,设置为解密模式
            cipher.init(Cipher.DECRYPT_MODE, key);
            //执行操作
            return cipher.doFinal(data);
        }
    
        public static String  showByteArray(byte[] data){
            if(null == data){
                return null;
            }
            StringBuilder sb = new StringBuilder("{");
            for(byte b:data){
                sb.append(b).append(",");
            }
            sb.deleteCharAt(sb.length()-1);
            sb.append("}");
            return sb.toString();
        }
    
        public static void main(String[] args) throws Exception {
            byte[] key = initSecretKey();
            System.out.println("key:"+Base64.encodeBase64String(key));
            System.out.println("key:"+showByteArray(key));
            
            String md5 ="951266EC66A9F9853BA0D165DCB866DE";
            String md5Temp = md5+"
    "+Base64.encodeBase64String(key);   //不能为字符串
            System.out.println("md5Temp="+ md5Temp);
            
            String filepath="./";
            RSAPublicKey publicKey=RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath));
            byte[] md5Encrypt=RSAEncrypt.encrypt(publicKey,md5Temp.getBytes());
            String cipher=Base64.encodeBase64String(md5Encrypt);
            
    //        byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),md5Temp.getBytes());
    //        String cipher=Base64.encodeBase64String(cipherData);
            System.out.println("cipher=" + cipher);
            
            //解密:
             //私钥解密过程
            byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decodeBase64(cipher));
            String restr=new String(res);
            System.out.println("原文:"+cipher);
    //        System.out.println("加密:"+cipher);
            System.out.println("解密:"+restr);
            System.out.println();
           
            
            //---------------------第二阶段
            String kekkk= "7HcrOV9DXSNvdj0Y7suWvQ==";
            System.out.println(showByteArray(Base64.decodeBase64(kekkk)));
    //        Key k = toKey(key);
            Key k = toKey(Base64.decodeBase64(kekkk));
    
            String data ="AES数据";
            System.out.println("加密前数据: string:"+data);
            System.out.println("加密前数据: byte[]:"+showByteArray(data.getBytes()));
            System.out.println();
            byte[] encryptData = encrypt(data.getBytes(), k);
            System.out.println("加密后数据: byte[]:"+showByteArray(encryptData));
    //        System.out.println("加密后数据: hexStr:"+Hex.encodeHexStr(encryptData));
            System.out.println();
            byte[] decryptData = decrypt(encryptData, k);
            System.out.println("解密后数据: byte[]:"+showByteArray(decryptData));
            System.out.println("解密后数据: string:"+new String(decryptData));
    
        }
    }

    rsa代码示例:

    package com.autoyol.util.security.test;
    import org.apache.commons.codec.binary.Base64;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.FileReader;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    
    
    /**
     * 参考java加密和解密的艺术和相关资料
     */
    public class RSAEncrypt {
        /**
         * 字节数据转字符串专用集合
         */
        private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
            '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
    
        /**
         * 随机生成密钥对
         */
        public static void genKeyPair(String filePath) {
            // KeyPairGenerator类用于生成公钥和私钥对,基于RSA算法生成对象
            KeyPairGenerator keyPairGen = null;
            try {
                keyPairGen = KeyPairGenerator.getInstance("RSA");
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            }
            // 初始化密钥对生成器,密钥大小为96-1024位
            keyPairGen.initialize(1024,new SecureRandom());
            // 生成一个密钥对,保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            // 得到私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // 得到公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            try {
                // 得到公钥字符串
                String publicKeyString = Base64.encodeBase64String(publicKey.getEncoded());
                // 得到私钥字符串
                String privateKeyString = Base64.encodeBase64String(privateKey.getEncoded());
                // 将密钥对写入到文件
                FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
                FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
                BufferedWriter pubbw = new BufferedWriter(pubfw);
                BufferedWriter pribw = new BufferedWriter(prifw);
                pubbw.write(publicKeyString);
                pribw.write(privateKeyString);
                pubbw.flush();
                pubbw.close();
                pubfw.close();
                pribw.flush();
                pribw.close();
                prifw.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 从文件中输入流中加载公钥
         *
         * @param in
         *            公钥输入流
         * @throws Exception
         *             加载公钥时产生的异常
         */
        public static String loadPublicKeyByFile(String path) throws Exception {
            try {
                BufferedReader br = new BufferedReader(new FileReader(path
                    + "/publicKey.keystore"));
                String readLine = null;
                StringBuilder sb = new StringBuilder();
                while ((readLine = br.readLine()) != null) {
                    sb.append(readLine);
                }
                br.close();
                return sb.toString();
            } catch (IOException e) {
                throw new Exception("公钥数据流读取错误");
            } catch (NullPointerException e) {
                throw new Exception("公钥输入流为空");
            }
        }
    
        /**
         * 从字符串中加载公钥
         *
         * @param publicKeyStr
         *            公钥数据字符串
         * @throws Exception
         *             加载公钥时产生的异常
         */
        public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
            throws Exception {
            try {
                byte[] buffer = Base64.decodeBase64(publicKeyStr);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
                return (RSAPublicKey) keyFactory.generatePublic(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("公钥非法");
            } catch (NullPointerException e) {
                throw new Exception("公钥数据为空");
            }
        }
    
        /**
         * 从文件中加载私钥
         *
         * @param keyFileName
         *            私钥文件名
         * @return 是否成功
         * @throws Exception
         */
        public static String loadPrivateKeyByFile(String path) throws Exception {
            try {
                BufferedReader br = new BufferedReader(new FileReader(path
                    + "/privateKey.keystore"));
                String readLine = null;
                StringBuilder sb = new StringBuilder();
                while ((readLine = br.readLine()) != null) {
                    sb.append(readLine);
                }
                br.close();
                return sb.toString();
            } catch (IOException e) {
                throw new Exception("私钥数据读取错误");
            } catch (NullPointerException e) {
                throw new Exception("私钥输入流为空");
            }
        }
    
        public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
            throws Exception {
            try {
                byte[] buffer = Base64.decodeBase64(privateKeyStr);
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("私钥非法");
            } catch (NullPointerException e) {
                throw new Exception("私钥数据为空");
            }
        }
    
        /**
         * 公钥加密过程
         *
         * @param publicKey
         *            公钥
         * @param plainTextData
         *            明文数据
         * @return
         * @throws Exception
         *             加密过程中的异常信息
         */
        public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
            throws Exception {
            if (publicKey == null) {
                throw new Exception("加密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密公钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 私钥加密过程
         *
         * @param privateKey
         *            私钥
         * @param plainTextData
         *            明文数据
         * @return
         * @throws Exception
         *             加密过程中的异常信息
         */
        public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
            throws Exception {
            if (privateKey == null) {
                throw new Exception("加密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 私钥解密过程
         *
         * @param privateKey
         *            私钥
         * @param cipherData
         *            密文数据
         * @return 明文
         * @throws Exception
         *             解密过程中的异常信息
         */
        public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
            throws Exception {
            if (privateKey == null) {
                throw new Exception("解密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        /**
         * 公钥解密过程
         *
         * @param publicKey
         *            公钥
         * @param cipherData
         *            密文数据
         * @return 明文
         * @throws Exception
         *             解密过程中的异常信息
         */
        public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
            throws Exception {
            if (publicKey == null) {
                throw new Exception("解密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密公钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        /**
         * 字节数据转十六进制字符串
         *
         * @param data
         *            输入数据
         * @return 十六进制内容
         */
        public static String byteArrayToString(byte[] data) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < data.length; i++) {
                // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
                stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
                // 取出字节的低四位 作为索引得到相应的十六进制标识符
                stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
                if (i < data.length - 1) {
                    stringBuilder.append(' ');
                }
            }
            return stringBuilder.toString();
        }
    
        public static void main(String[] args) throws Exception {
            String filepath="./";
    
    //        RSAEncrypt.genKeyPair(filepath);
    
    
            /**
             * --------------公钥加密私钥解密过程-------------------
            原文:951266EC66A9F9853BA0D165DCB866DE
            加密:cUXcyZvimOd51S5XhdHQXCXhfqpwgjL83fLBVMgFSwYCC7ea6VUwGXtwEdpc7F0SrOMAWrlF51VX2MGd+ieLwGsUibdiAbDhm6Iry44HMdtWIt2hm98ierHOfDSWDVsUJz/JEwP1VjX4C7qc1lQEagalncou2pvpjk55x0eF1e4=
            解密:951266EC66A9F9853BA0D165DCB866DE
             */
            
            System.out.println("--------------公钥加密私钥解密过程-------------------");
    //        String plainText="951266EC66A9F9853BA0D165DCB866DE";
    //        //公钥加密过程
    //        byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)),plainText.getBytes());
    //        String cipher=Base64.encodeBase64String(cipherData);
    //        //私钥解密过程
    //        byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decodeBase64(cipher));
    //        String restr=new String(res);
    //        System.out.println("原文:"+plainText);
    //        System.out.println("加密:"+cipher);
    //        System.out.println("解密:"+restr);
    //        System.out.println();
            
            String cipher="[B@dc08c3";
           //私钥解密过程
             byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)), Base64.decodeBase64(cipher));
             String restr=new String(res);
             System.out.println("原文:"+cipher);
    //         System.out.println("加密:"+cipher);
             System.out.println("解密:"+restr);
             System.out.println();
            
            /**
             * --------------私钥加密公钥解密过程-------------------
            原文:951266EC66A9F9853BA0D165DCB866DE
            加密:TWo3LW5CkaIgLeFIZVn9uFJxyCGSm90LSn72tNMJIsSg0HOcorXZsZmz1nG+jDHRysE6wxG3yAMjmHiemSyAhWDXDImLAhgag+kTkpsf7kx2o4EtY3ysKc2/OZwV3J/5OicFctql2oTkFNwf3UBfgdnHs+ucxRtj8P/ID6Klos0=
            解密:951266EC66A9F9853BA0D165DCB866DE
             */
            /*System.out.println("--------------私钥加密公钥解密过程-------------------");
            String plainText="951266EC66A9F9853BA0D165DCB866DE951266EC66A9F9853BA0D165DCB866DE";
            //私钥加密过程
            byte[] cipherData=RSAEncrypt.encrypt(RSAEncrypt.loadPrivateKeyByStr(RSAEncrypt.loadPrivateKeyByFile(filepath)),plainText.getBytes());
            String cipher=Base64.encodeBase64String(cipherData);
            //公钥解密过程
            byte[] res=RSAEncrypt.decrypt(RSAEncrypt.loadPublicKeyByStr(RSAEncrypt.loadPublicKeyByFile(filepath)), Base64.decodeBase64(cipher));
            String restr=new String(res);
            System.out.println("原文:"+plainText);
            System.out.println("加密:"+cipher);
            System.out.println("解密:"+restr);
            System.out.println();*/
    
    
        }
    }
  • 相关阅读:
    HDU 1728 逃离迷宫
    程序猿求职之道(《程序猿面试笔试宝典》)之不想签约,但也不想轻易放弃机会,怎么办?
    职场生涯(—)
    Python学习笔记24:Django搭建简单的博客站点(二)
    &quot;高可用方案工具包&quot; high availability toolkit 1.1
    [Swift]LeetCode421. 数组中两个数的最大异或值 | Maximum XOR of Two Numbers in an Array
    [Swift]LeetCode420. 强密码检验器 | Strong Password Checker
    [Swift]LeetCode419. 甲板上的战舰 | Battleships in a Board
    [Swift]LeetCode417. 太平洋大西洋水流问题 | Pacific Atlantic Water Flow
    [Swift通天遁地]七、数据与安全-(11)如何检测应用程序中的内存泄露
  • 原文地址:https://www.cnblogs.com/simpledev/p/5746445.html
Copyright © 2011-2022 走看看