国密算法SM4,3DES算法和AES三种加密算法的java实现

  • 2017-9-27 21:12
  • PHP二次开发
  • 阅读(117)
  • 评论(0)
  • 来源:互联网
  • 摘要: 国密算法SM4,3DES算法和AES三种加密算法的java实现国密SM4package test;import java.util.Arrays;public class SMS4 { private static final int ENCRYPT=1; private static final int DECRYPT=0; public stat ...
    国密算法SM4,3DES算法和AES三种加密算法的java实现

    国密SM4

    package test;  
      
    import java.util.Arrays;  
      
    public class SMS4 {  
          
        private static final int ENCRYPT=1;  
        private static final int DECRYPT=0;  
        public static final int ROUND=32;  
        private static final int BLOCK=16;  
          
        private byte[] Sbox={  
                (byte) 0xd6,(byte) 0x90,(byte) 0xe9,(byte) 0xfe,(byte) 0xcc,(byte) 0xe1,0x3d,(byte) 0xb7,0x16,(byte) 0xb6,0x14,(byte) 0xc2,0x28,(byte) 0xfb,0x2c,0x05,  
                0x2b,0x67,(byte) 0x9a,0x76,0x2a,(byte) 0xbe,0x04,(byte) 0xc3,(byte) 0xaa,0x44,0x13,0x26,0x49,(byte) 0x86,0x06,(byte) 0x99,  
                (byte) 0x9c,0x42,0x50,(byte) 0xf4,(byte) 0x91,(byte) 0xef,(byte) 0x98,0x7a,0x33,0x54,0x0b,0x43,(byte) 0xed,(byte) 0xcf,(byte) 0xac,0x62,  
                (byte) 0xe4,(byte) 0xb3,0x1c,(byte) 0xa9,(byte) 0xc9,0x08,(byte) 0xe8,(byte) 0x95,(byte) 0x80,(byte) 0xdf,(byte) 0x94,(byte) 0xfa,0x75,(byte) 0x8f,0x3f,(byte) 0xa6,  
                0x47,0x07,(byte) 0xa7,(byte) 0xfc,(byte) 0xf3,0x73,0x17,(byte) 0xba,(byte) 0x83,0x59,0x3c,0x19,(byte) 0xe6,(byte) 0x85,0x4f,(byte) 0xa8,  
                0x68,0x6b,(byte) 0x81,(byte) 0xb2,0x71,0x64,(byte) 0xda,(byte) 0x8b,(byte) 0xf8,(byte) 0xeb,0x0f,0x4b,0x70,0x56,(byte) 0x9d,0x35,  
                0x1e,0x24,0x0e,0x5e,0x63,0x58,(byte) 0xd1,(byte) 0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,(byte) 0x87,  
                (byte) 0xd4,0x00,0x46,0x57,(byte) 0x9f,(byte) 0xd3,0x27,0x52,0x4c,0x36,0x02,(byte) 0xe7,(byte) 0xa0,(byte) 0xc4,(byte) 0xc8,(byte) 0x9e,  
                (byte) 0xea,(byte) 0xbf,(byte) 0x8a,(byte) 0xd2,0x40,(byte) 0xc7,0x38,(byte) 0xb5,(byte) 0xa3,(byte) 0xf7,(byte) 0xf2,(byte) 0xce,(byte) 0xf9,0x61,0x15,(byte) 0xa1,  
                (byte) 0xe0,(byte) 0xae,0x5d,(byte) 0xa4,(byte) 0x9b,0x34,0x1a,0x55,(byte) 0xad,(byte) 0x93,0x32,0x30,(byte) 0xf5,(byte) 0x8c,(byte) 0xb1,(byte) 0xe3,  
                0x1d,(byte) 0xf6,(byte) 0xe2,0x2e,(byte) 0x82,0x66,(byte) 0xca,0x60,(byte) 0xc0,0x29,0x23,(byte) 0xab,0x0d,0x53,0x4e,0x6f,  
                (byte) 0xd5,(byte) 0xdb,0x37,0x45,(byte) 0xde,(byte) 0xfd,(byte) 0x8e,0x2f,0x03,(byte) 0xff,0x6a,0x72,0x6d,0x6c,0x5b,0x51,  
                (byte) 0x8d,0x1b,(byte) 0xaf,(byte) 0x92,(byte) 0xbb,(byte) 0xdd,(byte) 0xbc,0x7f,0x11,(byte) 0xd9,0x5c,0x41,0x1f,0x10,0x5a,(byte) 0xd8,  
                0x0a,(byte) 0xc1,0x31,(byte) 0x88,(byte) 0xa5,(byte) 0xcd,0x7b,(byte) 0xbd,0x2d,0x74,(byte) 0xd0,0x12,(byte) 0xb8,(byte) 0xe5,(byte) 0xb4,(byte) 0xb0,  
                (byte) 0x89,0x69,(byte) 0x97,0x4a,0x0c,(byte) 0x96,0x77,0x7e,0x65,(byte) 0xb9,(byte) 0xf1,0x09,(byte) 0xc5,0x6e,(byte) 0xc6,(byte) 0x84,  
                0x18,(byte) 0xf0,0x7d,(byte) 0xec,0x3a,(byte) 0xdc,0x4d,0x20,0x79,(byte) 0xee,0x5f,0x3e,(byte) 0xd7,(byte) 0xcb,0x39,0x48  
        };  
          
        private int[] CK={  
                0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,  
                0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,  
                0xe0e7eef5, 0xfc030a11, 0x181f262d, 0x343b4249,  
                0x50575e65, 0x6c737a81, 0x888f969d, 0xa4abb2b9,  
                0xc0c7ced5, 0xdce3eaf1, 0xf8ff060d, 0x141b2229,  
                0x30373e45, 0x4c535a61, 0x686f767d, 0x848b9299,  
                0xa0a7aeb5, 0xbcc3cad1, 0xd8dfe6ed, 0xf4fb0209,  
                0x10171e25, 0x2c333a41, 0x484f565d, 0x646b7279  
        };  
          
        private int Rotl(int x,int y)  
        {  
            return x<<y|x>>>(32-y);  
        }  
          
        private int ByteSub(int A)  
        {  
            return (Sbox[A>>>24&0xFF]&0xFF)<<24|(Sbox[A>>>16&0xFF]&0xFF)<<16|(Sbox[A>>>8&0xFF]&0xFF)<<8|(Sbox[A&0xFF]&0xFF);  
        }  
      
        private int L1(int B)  
        {  
            return B^Rotl(B,2)^Rotl(B,10)^Rotl(B,18)^Rotl(B,24);  
        //  return B^(B<<2|B>>>30)^(B<<10|B>>>22)^(B<<18|B>>>14)^(B<<24|B>>>8);  
        }  
          
        private int L2(int B)  
        {  
            return B^Rotl(B,13)^Rotl(B,23);  
        //  return B^(B<<13|B>>>19)^(B<<23|B>>>9);  
        }  
          
          
        void SMS4Crypt(byte[] Input,byte[] Output,int[] rk)  
        {  
            int r,mid,x0,x1,x2,x3;  
            int[] x= new int[4];  
            int[] tmp = new int[4];  
            for(int i=0;i<4;i++)  
            {  
                tmp[0]=Input[0+4*i]&0xff;  
                tmp[1]=Input[1+4*i]&0xff;  
                tmp[2]=Input[2+4*i]&0xff;  
                tmp[3]=Input[3+4*i]&0xff;  
                x[i]=tmp[0]<<24|tmp[1]<<16|tmp[2]<<8|tmp[3];  
            //  x[i]=(Input[0+4*i]<<24|Input[1+4*i]<<16|Input[2+4*i]<<8|Input[3+4*i]);  
            }  
            for(r=0;r<32;r+=4)  
            {  
                mid=x[1]^x[2]^x[3]^rk[r+0];  
                mid=ByteSub(mid);  
                x[0]=x[0]^L1(mid);   //x4  
                  
                mid=x[2]^x[3]^x[0]^rk[r+1];  
                mid=ByteSub(mid);  
                x[1]=x[1]^L1(mid);  //x5  
                  
                mid=x[3]^x[0]^x[1]^rk[r+2];  
                mid=ByteSub(mid);  
                x[2]=x[2]^L1(mid);  //x6  
                  
                mid=x[0]^x[1]^x[2]^rk[r+3];  
                mid=ByteSub(mid);  
                x[3]=x[3]^L1(mid);  //x7  
            }  
              
            //Reverse  
            for(int j=0;j<16;j+=4)  
            {  
                Output[j]  =(byte) (x[3-j/4]>>>24&0xFF);  
                Output[j+1]=(byte) (x[3-j/4]>>>16&0xFF);  
                Output[j+2]=(byte) (x[3-j/4]>>>8&0xFF);  
                Output[j+3]=(byte) (x[3-j/4]&0xFF);  
            }  
        }  
          
        private void SMS4KeyExt(byte[] Key,int[] rk,int CryptFlag)  
        {  
            int r,mid;  
            int[] x= new int[4];  
            int[] tmp =new int[4];  
            for(int i=0;i<4;i++)  
            {  
                tmp[0]=Key[0+4*i]&0xFF;  
                tmp[1]=Key[1+4*i]&0xff;  
                tmp[2]=Key[2+4*i]&0xff;  
                tmp[3]=Key[3+4*i]&0xff;  
                x[i]=tmp[0]<<24|tmp[1]<<16|tmp[2]<<8|tmp[3];  
            //  x[i]=Key[0+4*i]<<24|Key[1+4*i]<<16|Key[2+4*i]<<8|Key[3+4*i];  
            }  
            x[0]^=0xa3b1bac6;  
            x[1]^=0x56aa3350;  
            x[2]^=0x677d9197;  
            x[3]^=0xb27022dc;  
            for(r=0;r<32;r+=4)  
            {  
                mid=x[1]^x[2]^x[3]^CK[r+0];  
                mid=ByteSub(mid);  
                rk[r+0]=x[0]^=L2(mid);      //rk0=K4  
                  
                mid=x[2]^x[3]^x[0]^CK[r+1];  
                mid=ByteSub(mid);  
                rk[r+1]=x[1]^=L2(mid);      //rk1=K5  
                  
                mid=x[3]^x[0]^x[1]^CK[r+2];  
                mid=ByteSub(mid);  
                rk[r+2]=x[2]^=L2(mid);      //rk2=K6  
                  
                mid=x[0]^x[1]^x[2]^CK[r+3];  
                mid=ByteSub(mid);  
                rk[r+3]=x[3]^=L2(mid);      //rk3=K7  
            }  
              
            if(CryptFlag==DECRYPT)  
            {  
                for(r=0;r<16;r++)  
                {  
                    mid=rk[r];  
                    rk[r]=rk[31-r];  
                    rk[31-r]=mid;  
                }  
            }  
        }  
          
        public int sms4(byte[] in,int inLen,byte[] key,byte[] out,int CryptFlag)  
        {  
            int point=0;  
            int[] round_key=new int[ROUND];   
            //int[] round_key={0};  
            SMS4KeyExt(key,round_key,CryptFlag);  
            byte[] input = new byte[16];  
            byte[] output = new byte[16];  
              
            while(inLen>=BLOCK)  
            {  
                input=Arrays.copyOfRange(in, point, point+16);  
            //  output=Arrays.copyOfRange(out, point, point+16);  
                SMS4Crypt(input,output,round_key);  
                System.arraycopy(output, 0, out, point, BLOCK);  
                inLen-=BLOCK;  
                point+=BLOCK;  
            }  
              
            return 0;  
        }  
    }  

    测试
    package test;  
      
    public class testMain {  
      
        /** 
         * @param args 
         */  
        public static void main(String[] args) {  
            // TODO Auto-generated method stub  
            byte[] in={0x01,0x23,0x45,0x67,(byte) 0x89,(byte) 0xab,(byte) 0xcd,(byte) 0xef,(byte) 0xfe,(byte) 0xdc,(byte) 0xba,(byte) 0x98,0x76,0x54,0x32,0x10};  
            byte[] in1={  
                    0x01,0x23,0x45,0x67,(byte) 0x89,(byte) 0xab,(byte) 0xcd,(byte) 0xef,(byte) 0xfe,(byte) 0xdc,(byte) 0xba,(byte) 0x98,0x76,0x54,0x32,0x10,  
                    0x01,0x23,0x45,0x67,(byte) 0x89,(byte) 0xab,(byte) 0xcd,(byte) 0xef,(byte) 0xfe,(byte) 0xdc,(byte) 0xba,(byte) 0x98,0x76,0x54,0x32,0x10  
                    };  
            byte[] key={0x01,0x23,0x45,0x67,(byte) 0x89,(byte) 0xab,(byte) 0xcd,(byte) 0xef,(byte) 0xfe,(byte) 0xdc,(byte) 0xba,(byte) 0x98,0x76,0x54,0x32,0x10};  
            SMS4 sm4=new SMS4();  
            int inLen=16,ENCRYPT=1,DECRYPT=0,inlen1=32;  
            byte[] out=new byte[16];  
            byte[] out1=new byte[32];  
            long starttime;  
              
            //加密 128bit  
            starttime=System.nanoTime();  
            sm4.sms4(in, inLen, key, out, ENCRYPT);  
            System.out.println("加密1个分组执行时间: "+(System.nanoTime()-starttime)+"ns");  
            System.out.println("加密结果:");  
            for(int i=0;i<16;i++)  
                System.out.print(Integer.toHexString(out[i]&0xff)+"\t");  
            //解密 128bit  
            System.out.println();  
            sm4.sms4(out, inLen, key, in, DECRYPT);  
            System.out.println("解密结果:");  
            for(int i=0;i<16;i++)  
                System.out.print(Integer.toHexString(in[i]&0xff)+"\t");  
            //加密多个分组  
            System.out.println();  
            sm4.sms4(in1, inlen1, key, out1, ENCRYPT);  
            System.out.println("\r多分组加密结果:");  
            for(int i=0;i<32;i++)  
                System.out.print(Integer.toHexString(out1[i]&0xff)+"\t");  
            //解密多个分组  
            System.out.println();  
            sm4.sms4(out1, inlen1, key, in1, DECRYPT);  
            System.out.println("多分组解密结果:");  
            for(int i=0;i<32;i++)  
                System.out.print(Integer.toHexString(in1[i]&0xff)+"\t");  
            //1,000,000次加密  
            System.out.println();  
            starttime=System.currentTimeMillis();  
            for(int i=1;i<1000000;i++)  
            {  
                sm4.sms4(in, inLen, key, out, ENCRYPT);  
                in=out;  
            }  
            sm4.sms4(in, inLen, key, out, ENCRYPT);  
            System.out.println("\r1000000次加密执行时间: "+(System.currentTimeMillis()-starttime)+"ms");  
            System.out.println("加密结果:");  
            for(int i=0;i<16;i++)  
                System.out.print(Integer.toHexString(out[i]&0xff)+"\t");  
              
        }  
      
    }  

    3DES
    package test;  
      
    import java.security.InvalidKeyException;  
    import java.security.Key;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.Security;  
    import java.security.spec.InvalidKeySpecException;  
      
    import javax.crypto.Cipher;  
    import javax.crypto.SecretKeyFactory;  
    import javax.crypto.spec.DESedeKeySpec;  
    import javax.crypto.spec.IvParameterSpec;  
      
    import org.apache.commons.codec.binary.Base64;  
    import org.bouncycastle.jce.provider.BouncyCastleProvider;  
      
    public class ThreeDESUtil {  
         // 算法名称   
        public static final String KEY_ALGORITHM = "desede";  
        // 算法名称/加密模式/填充方式   
        public static final String CIPHER_ALGORITHM = "desede/CBC/NoPadding";  
      
        /**  
         * CBC加密  
         * @param key 密钥  
         * @param keyiv IV  
         * @param data 明文  
         * @return Base64编码的密文  
         * @throws Exception  
         */  
        public static byte[] des3EncodeCBC(byte[] key, byte[] keyiv, byte[] data) throws Exception {  
            Security.addProvider(new BouncyCastleProvider());   
            Key deskey = keyGenerator(new String(key));  
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
            IvParameterSpec ips = new IvParameterSpec(keyiv);  
            cipher.init(Cipher.ENCRYPT_MODE, deskey, ips);  
            byte[] bOut = cipher.doFinal(data);  
            for (int k = 0; k < bOut.length; k++) {  
                //System.out.print(bOut[k] + " ");  
            }  
            //System.out.println("");  
            return bOut;  
        }  
      
        /**  
         *    
         * 生成密钥key对象  
         * @param KeyStr 密钥字符串  
         * @return 密钥对象  
         * @throws InvalidKeyException    
         * @throws NoSuchAlgorithmException    
         * @throws InvalidKeySpecException    
         * @throws Exception  
         */  
        private static Key keyGenerator(String keyStr) throws Exception {  
            byte input[] = HexString2Bytes(keyStr);  
            DESedeKeySpec KeySpec = new DESedeKeySpec(input);  
            SecretKeyFactory KeyFactory = SecretKeyFactory.getInstance(KEY_ALGORITHM);  
            return ((Key) (KeyFactory.generateSecret(((java.security.spec.KeySpec) (KeySpec)))));  
        }  
      
        private static int parse(char c) {  
            if (c >= 'a') return (c - 'a' + 10) & 0x0f;  
            if (c >= 'A') return (c - 'A' + 10) & 0x0f;  
            return (c - '0') & 0x0f;  
        }  
       
        // 从十六进制字符串到字节数组转换   
        public static byte[] HexString2Bytes(String hexstr) {  
            byte[] b = new byte[hexstr.length() / 2];  
            int j = 0;  
            for (int i = 0; i < b.length; i++) {  
                char c0 = hexstr.charAt(j++);  
                char c1 = hexstr.charAt(j++);  
                b[i] = (byte) ((parse(c0) << 4) | parse(c1));  
            }  
            return b;  
        }  
      
        /**  
         * CBC解密  
         * @param key 密钥  
         * @param keyiv IV  
         * @param data Base64编码的密文  
         * @return 明文  
         * @throws Exception  
         */  
        public static byte[] des3DecodeCBC(byte[] key, byte[] keyiv, byte[] data) throws Exception {  
            Key deskey = keyGenerator(new String(key));  
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
            IvParameterSpec ips = new IvParameterSpec(keyiv);  
            cipher.init(Cipher.DECRYPT_MODE, deskey, ips);  
            byte[] bOut = cipher.doFinal(data);  
            return bOut;  
        }  
      
        public static void main(String[] args) throws Exception {  
            byte[] key = "6C4E60E55552386C759569836DC0F83869836DC0F838C0F7".getBytes();  
            byte[] keyiv = { 1, 2, 3, 4, 5, 6, 7, 8};  
            byte[] data = "aaaaaaaa".getBytes("UTF-8");  
            System.out.println("data.length=" + data.length);  
            System.out.println("CBC加密解密");  
            byte[] str5 = des3EncodeCBC(key, keyiv, data);  
           // System.out.println(new sun.misc.BASE64Encoder().encode(str5));  
            System.out.println(new Base64().encodeToString(str5));  
      
            byte[] str6 = des3DecodeCBC(key, keyiv, str5);  
            System.out.println(new String(str6, "UTF-8"));  
        }  
    }  

    DES
    [java] view plain copy
    package test;  
      
    import java.security.InvalidKeyException;  
    import java.security.Key;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.SecureRandom;  
    import java.security.spec.InvalidKeySpecException;  
      
    import javax.crypto.Cipher;  
    import javax.crypto.SecretKey;  
    import javax.crypto.SecretKeyFactory;  
    import javax.crypto.spec.DESKeySpec;  
      
    import org.apache.commons.codec.binary.Base64;  
      
    public class DESUtil {  
      
         //算法名称   
        public static final String KEY_ALGORITHM = "DES";  
        //算法名称/加密模式/填充方式   
        //DES共有四种工作模式-->>ECB:电子密码本模式、CBC:加密分组链接模式、CFB:加密反馈模式、OFB:输出反馈模式  
        public static final String CIPHER_ALGORITHM = "DES/ECB/NoPadding";  
      
        /** 
         *    
         * 生成密钥key对象 
         * @param KeyStr 密钥字符串  
         * @return 密钥对象  
         * @throws InvalidKeyException    
         * @throws NoSuchAlgorithmException    
         * @throws InvalidKeySpecException    
         * @throws Exception  
         */  
        private static SecretKey keyGenerator(String keyStr) throws Exception {  
            byte input[] = HexString2Bytes(keyStr);  
            DESKeySpec desKey = new DESKeySpec(input);  
            //创建一个密匙工厂,然后用它把DESKeySpec转换成  
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");  
            SecretKey securekey = keyFactory.generateSecret(desKey);  
            return securekey;  
        }  
      
        private static int parse(char c) {  
            if (c >= 'a') return (c - 'a' + 10) & 0x0f;  
            if (c >= 'A') return (c - 'A' + 10) & 0x0f;  
            return (c - '0') & 0x0f;  
        }  
      
        // 从十六进制字符串到字节数组转换   
        public static byte[] HexString2Bytes(String hexstr) {  
            byte[] b = new byte[hexstr.length() / 2];  
            int j = 0;  
            for (int i = 0; i < b.length; i++) {  
                char c0 = hexstr.charAt(j++);  
                char c1 = hexstr.charAt(j++);  
                b[i] = (byte) ((parse(c0) << 4) | parse(c1));  
            }  
            return b;  
        }  
      
        /**  
         * 加密数据 
         * @param data 待加密数据 
         * @param key 密钥 
         * @return 加密后的数据  
         */  
        public static String encrypt(String data, String key) throws Exception {  
            Key deskey = keyGenerator(key);  
            // 实例化Cipher对象,它用于完成实际的加密操作  
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
            SecureRandom random = new SecureRandom();  
            // 初始化Cipher对象,设置为加密模式  
            cipher.init(Cipher.ENCRYPT_MODE, deskey, random);  
            byte[] results = cipher.doFinal(data.getBytes());  
            // 该部分是为了与加解密在线测试网站(http://tripledes.online-domain-tools.com/)的十六进制结果进行核对  
            for (int i = 0; i < results.length; i++) {  
                System.out.print(results[i] + " ");  
            }  
            System.out.println();  
            // 执行加密操作。加密后的结果通常都会用Base64编码进行传输   
            return Base64.encodeBase64String(results);  
        }  
      
        /**  
         * 解密数据  
         * @param data 待解密数据  
         * @param key 密钥  
         * @return 解密后的数据  
         */  
        public static String decrypt(String data, String key) throws Exception {  
            Key deskey = keyGenerator(key);  
            Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);  
            //初始化Cipher对象,设置为解密模式  
            cipher.init(Cipher.DECRYPT_MODE, deskey);  
            // 执行解密操作  
            return new String(cipher.doFinal(Base64.decodeBase64(data)));  
        }  
      
        public static void main(String[] args) throws Exception {  
            String source = "amigoxie";  
            System.out.println("原文: " + source);  
            String key = "A1B2C3D4E5F60708";  
            String encryptData = encrypt(source, key);  
            System.out.println("加密后: " + encryptData);  
            String decryptData = decrypt(encryptData, key);  
            System.out.println("解密后: " + decryptData);  
        }  
    }  

    AES
    package test;  
      
    import java.io.UnsupportedEncodingException;  
    import java.security.InvalidKeyException;  
    import java.security.NoSuchAlgorithmException;  
    import java.security.SecureRandom;  
      
    import javax.crypto.BadPaddingException;  
    import javax.crypto.Cipher;  
    import javax.crypto.IllegalBlockSizeException;  
    import javax.crypto.KeyGenerator;  
    import javax.crypto.NoSuchPaddingException;  
    import javax.crypto.SecretKey;  
    import javax.crypto.spec.SecretKeySpec;  
      
    public class AESUtil {  
      
        /** 
         * 加密 
         *  
         * @param content 需要加密的内容 
         * @param password  加密密码 
         * @return 
         */  
        public static byte[] encrypt(String content, String password) {  
                try {             
                        KeyGenerator kgen = KeyGenerator.getInstance("AES");  
                        kgen.init(128, new SecureRandom(password.getBytes()));  
                        SecretKey secretKey = kgen.generateKey();  
                        byte[] enCodeFormat = secretKey.getEncoded();  
                        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
                        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 (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();  
                }  
                return null;  
        }  
          
          
          
          
          
        /**解密 
         * @param content  待解密内容 
         * @param password 解密密钥 
         * @return 
         */  
        public static byte[] decrypt(byte[] content, String password) {  
                try {  
                         KeyGenerator kgen = KeyGenerator.getInstance("AES");  
                         kgen.init(128, new SecureRandom(password.getBytes()));  
                         SecretKey secretKey = kgen.generateKey();  
                         byte[] enCodeFormat = secretKey.getEncoded();  
                         SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");              
                         Cipher cipher = Cipher.getInstance("AES");// 创建密码器  
                        cipher.init(Cipher.DECRYPT_MODE, key);// 初始化  
                        byte[] result = cipher.doFinal(content);  
                        return 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();  
                }  
                return null;  
        }  
          
          
        /**将二进制转换成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();  
        }  
          
          
          
          
        /**将16进制转换为二进制 
         * @param hexStr 
         * @return 
         */  
        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;  
        }  
          
        public static void main(String[] args) {  
            String name = "sysadmin";  
            String password = "venus.sysadmin";  
            //加密  
            System.out.println("加密前:" + name);  
            byte[] encryptResult = encrypt(name, password);  
            String encryptResultStr = parseByte2HexStr(encryptResult);  
            System.out.println("加密后:" + encryptResultStr);  
            //解密  
            byte[] decryptFrom = parseHexStr2Byte(encryptResultStr);  
            byte[] decryptResult = decrypt(decryptFrom,password);  
            System.out.println("解密后:" + new String(decryptResult));  
        }  
    }  



    PHP技术交流QQ群:422137578

    除非注明,文章均为 PHP二次开发 原创,转载请注明本文地址:http://www.php2.cc/article-2656-1.html

    相关阅读

    最新评论

    用户名:  *

    邮 箱:  *

    网 址: 注意加上“http://”哦!