AES加密解密算法---java

package com.BFGJ.AES;

import java.util.Random;
import java.util.StringTokenizer;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * PBEWithMD5AndDES算法加密解密
 *
 * @author Json * @version
 */
public class EncryptImpl implements Encrypt
{
    public EncryptImpl()
    {
    }

    private final static Encrypt encrypt= new EncryptImpl();

    private final String  password="e_f_codd";

    private final String  encoding="GBK";

    /**
     * 16进制字符数组
     */
    private final static String[] hexDigits =
            {
            "0", "1", "2", "3", "4", "5", "6", "7",
            "8", "9", "a", "b", "c", "d", "e", "f"};
    /**
     * AES密匙
     */
    private final static byte[] keyByte =
            {
            0x11, 0x22, 0x4F, 0x58, (byte)0x88, 0x10, 0x40, 0x38,
            0x28, 0x25, 0x79, 0x51, (byte)0xCB, (byte)0xDD, 0x55,
            0x66}; //16字节的密钥,可以改变
    /**
     * 一位Byte到16进制字符串的转换
     * @param b byte
     * @return String
     */
    private static String byteToHexString(byte b)
    {
        int n = b;
        if(n < 0)
        {
            n = 256 + n;
        }
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }

    /**
     * Byte数组到16进制字符串的转换
     * @param b byte[]
     * @return String
     */
    private static String byteArrayToHexString(byte[] b)
    {
        StringBuffer resultSb = new StringBuffer();
        for(int i = 0; i < b.length; i++)
        {
            resultSb.append(byteToHexString(b[i]));
        }
        return resultSb.toString();
    }

    /**
     * 16进制字符串到Byte转换
     * @param b String
     * @return byte
     */
    private static byte HexStringTobyte(String b)
    {
        int By = 0;
        String b1 = b.substring(0, 1);
        int b11 = -1;
        String b2 = b.substring(1);
        int b12 = -1;
        for(int i = 0; i < 16; i++)
        {
            if(b1.equals(hexDigits[i]))
            {
                b11 = i;
            }
        }
        for(int i = 0; i < 16; i++)
        {
            if(b2.equals(hexDigits[i]))
            {
                b12 = i;
            }
        }
        By = b11 * 16 + b12;
        if(By > 256)
        {
            By = By - 256;
        }
        return(byte)By;
    }

    /**
     * 16进制字符串到Byte数组的转换
     * @param b String
     * @return byte[]
     */
    private static byte[] HexStringTobyteArray(String b)
    {
        byte[] r = new byte[b.length()/2];
        for(int i = 0; i < b.length() / 2; i++)
        {
            r[i] = HexStringTobyte(b.substring(i * 2, i * 2 + 2));
        }
        return r;
    }

    public static Encrypt getInstance()
    {
        return encrypt;
    }

    /**
     * 将加密文本进行解密;
     *
     * @param encryptText
     *            String
     * @return String
     */
    public String deCodeAES(String encryptText) throws Exception
    {
        //通过SecretKeySpec形成一个key
        SecretKey key = new SecretKeySpec(keyByte, "AES");
        //获得一个私鈅加密类Cipher,ECB是加密方式,PKCS5Padding是填充方法
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        //使用私鈅解密
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] NewCipherText = HexStringTobyteArray(encryptText);
        byte[] newString = cipher.doFinal(NewCipherText);
        return new String(newString, encoding);

    }

    /**
     * 将传进来的明文以AES算法进行加密
     *
     * @param text
     *            String
     * @return String
     */
    public String enCodeAES(String text) throws Exception
    {
        byte[] OriByte = text.getBytes(encoding);
        //通过SecretKeySpec形成一个key
        SecretKey key = new SecretKeySpec(keyByte, "AES");
        //获得一个私鈅加密类Cipher,ECB是加密方式,PKCS5Padding是填充方法
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        //使用私鈅加密
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] OriCipherText = cipher.doFinal(OriByte);
        String b = byteArrayToHexString(OriCipherText);
        return b; //密码,转换成16进制
    }
    /**
     * 将加密文本进行解密;
     *
     * @param encryptText
     *            String
     * @return String
     */
    public String decrypt(String encryptText) throws Exception
    {
        if (encryptText == null || encryptText.length() == 0) { return ""; }
        PBEKeySpec pbks = new PBEKeySpec((password).toCharArray());

        SecretKeyFactory skf = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
        SecretKey k = skf.generateSecret(pbks);

        StringTokenizer st = new StringTokenizer(hex2string(encryptText), " ");
        int num = 0;
        byte[] salt = new byte[8];
        while (st.hasMoreTokens() && (num < 8))
        {
            salt[num] = (byte) (Integer.parseInt(st.nextToken()));
            num++;
        }

        int count = 0;
        byte[] cbtemp = new byte[2000];
        while (st.hasMoreTokens())
        {
            cbtemp[count] = (byte) (Integer.parseInt(st.nextToken()));
            count++;
        }
        byte[] cb = new byte[count];
        for (int i = 0; i < cb.length; i++)
        {
            cb[i] = cbtemp[i];
        }
        Cipher cp = Cipher.getInstance("PBEWithMD5AndDES");
        PBEParameterSpec ps = new PBEParameterSpec(salt, 1000);
        cp.init(Cipher.DECRYPT_MODE, k, ps);

        byte[] ptext = cp.doFinal(cb);

        return new String(ptext);

    }

    /**
     * 将传进来的明文以PBEWithMD5AndDES算法进行加密
     *
     * @param text
     *            String
     * @return String
     */
    public String encrypt(String text) throws Exception
    {
        if (text == null || text.length() == 0) { return ""; }

        PBEKeySpec pbks = new PBEKeySpec(password.toCharArray());
        SecretKeyFactory skf = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
        SecretKey k = skf.generateSecret(pbks);
        byte[] salt = new byte[8];
        Random r = new Random();
        r.nextBytes(salt);
        Cipher cp = Cipher.getInstance("PBEWithMD5AndDES");
        PBEParameterSpec ps = new PBEParameterSpec(salt, 1000);
        cp.init(Cipher.ENCRYPT_MODE, k, ps);
        byte[] ptext = text.getBytes(encoding);
        byte[] ctext = cp.doFinal(ptext);

        String result = "";
        for (int i = 0; i < salt.length; i++)
        {
            result += salt[i] + " ";
        }

        for (int i = 0; i < ctext.length; i++)
        {
            result += ctext[i] + " ";
        }
        return string2hex(result);
    }

    /**
     * 将16进制编码的字符串转换为带有空格分隔的字符串
     * 比如:F89ADFCA2AE9719817D3575A9540600C ==>  -8 -102 -33 -54 42 -23 113 -104 23 -45 87 90 -107 64 96 12
     * @param s
     * @return
     */
    private String hex2string(String s)
    {
        String ret = "";
        for (int i = 0; i < s.length() / 2; i++)
        {
            ret += String.valueOf(Integer.parseInt(s.substring(2 * i, 2 * i + 2), 16)) + " ";

        }
        if (ret.endsWith(" "))
            return ret.substring(0, ret.length() - 1);
        return ret;
    }
    /**
     * 将加密的带有空格分隔的字符转换为16进制编码的字符串.
     * 比如:-8 -102 -33 -54 42 -23 113 -104 23 -45 87 90 -107 64 96 12  ==> F89ADFCA2AE9719817D3575A9540600C
     * @param str
     * @return
     */
    private String string2hex(String str)
    {
        String[] split = str.split(" ");
        byte[] b = new byte[split.length];
        for (int i = 0; i < split.length; i++)
        {
            b[i] = Byte.parseByte(split[i]);
        }

        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++)
        {
            stmp = (Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1)
                hs = hs + "0" + stmp;
            else hs = hs + stmp;

        }
        return hs.toUpperCase();
    }

    public static void main(String[] args)
    {
        try
        {
            EncryptImpl en = (EncryptImpl) EncryptImpl.getInstance();
            //要加密的用户工号
            String userid = "1";
            //用户工号加密后的值
            String e_userid = en.encrypt(userid);
            System.out.println("encrypt-->"+e_userid);
            System.out.println("enCodeAES-->"+en.enCodeAES(userid));
            //对加密的用户工号进行解密
            System.out.println(en.decrypt(e_userid).equals(userid));

        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

}
时间: 2024-11-06 03:29:26

AES加密解密算法---java的相关文章

php与java通用AES加密解密算法

php与java通用AES加密解密算法 AES指高级加密标准(Advanced Encryption Standard),是当前最流行的一种密码算法,在web应用开发,特别是对外提供接口时经常会用到,下面是我整理的一套php与java通用的AES加密解密算法. php版代码如下: <?php class CryptAES { protected $cipher = MCRYPT_RIJNDAEL_128; protected $mode = MCRYPT_MODE_ECB; protected

AES加密解密在JAVA和ANDROID下互通

<span style="font-family: Arial, Helvetica, sans-serif;">昨天外包安卓的那个人说AES的加解密结果不一样,于是百度搜索发现还真是!</span> 贴上AES加密核心: Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding"); cipher.init(Cipher.ENCRYPT_MODE, key, zeroIv); CBC是

C# AES加密解密算法

/// <summary> /// AES加密 /// </summary> /// <param name="encryptStr">明文</param> /// <param name="key">密钥</param> /// <returns></returns> public static string Encrypt(string encryptStr,stri

AES加密解密的java工具类

百度百科一下,AES:高级加密标准(英语:Advanced Encryption Standard,缩写:AES),在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准.这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用.经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准.2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一. AESCip

AES加密解密算法——使用.NET中Rijndael实现

public sealed class RijndaelEncDec { /// <summary> /// 初始化加密的key /// </summary> public static string Password { get;set; } private static byte[] Encrypt(byte[] clearData, byte[] Key, byte[] IV) { MemoryStream ms = new MemoryStream(); Rijndael

非对称技术栈实现AES加密解密

非对称技术栈实现AES加密解密 正如前面的一篇文章所述,https协议的SSL层是实现在传输层之上,应用层之下,也就是说在应用层上看到的请求还是明码的,对于某些场景下要求这些http请求参数是非可读的,这就要求在前端和后端不同的技术栈上完成信息的加密解密.当然我们通常完成这样专业的功能都会考虑使用相应的框架或者程序库来完成功能,前端或者NodeJS平台通常是JavaScript语言,JavaScript主流的加密解密库分别是SjclJS和CryptoJS, 本文以CryptoJS为例进行讨论.另

AES-128-ECB 16进制加密解密算法

import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; /** * AES加密解密算法 * 默认采用AES-128-ECB加密模式 */ public class AESUtils { private static final String SKEY = "uHNTivV09dQxLor9"; /** * 加密 * @param sSrc * @return * @throws Exception */ p

Java 关于密码处理的工具类[MD5编码][AES加密/解密]

项目中又遇到了加密问题,又去翻了半天,然后做测试,干脆就把常用的两类小结一下. 1.第一种所谓的MD5加密 其实也不算加密,只是基于Hash算法的不可逆编码而已,等于说,一旦经过MD5处理,是不可能从编码后的字符串反推回去的. MD5的方法是基于散列的.本身信息不全.理论上是不能还原成唯一字符串的. 网上所谓的解密,也只是拥有一个足够大的字典映射,将编码前的源字符和编码后的目标字符关联起来而已,大多数常见的还行,复杂点的估计就会话费很长时间,有兴趣的可以试试. 至于MD5的用法,在初次录入的时候

Aes 加密解密 java加密解密

使用AES加密解密代码详解 首先,如果是使用nodejs + vue 写的前端, 那么你需要npm 加载一个js文件 npm i crypto-js --save --save-exact npm install crypto-js java代码加密解密类 package com.telling.util.crypto; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; import org.apache.co