AES加密DES加密MD5加密类

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;

//加密工具类
public class DesKeyUtil {
    //加密
    public static String Encrypt(String sSrc, String sKey)
            throws Exception
    {
        if (sKey == null)
        {
            System.out.print("Key为空null");
            return null;
        }
        // 判断Key是否为16位
        if (sKey.length() != 16)
        {
            System.out.print("Key长度不是16位");
            return null;
        }
        byte[] raw = sKey.getBytes("utf-8");
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");// "算法/模式/补码方式"
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));

        return new Base64().encodeToString(encrypted);// 此处使用BASE64做转码功能，同时能起到2次加密的作用。
    }


    // 解密
    public static String Decrypt(String sSrc, String sKey)
            throws Exception
    {
        try
        {
            // 判断Key是否正确
            if (sKey == null)
            {
                System.out.print("Key为空null");
                return null;
            }
            // 判断Key是否为16位
            if (sKey.length() != 16)
            {
                System.out.print("Key长度不是16位");
                return null;
            }
            byte[] raw = sKey.getBytes("utf-8");
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            byte[] encrypted1 = new Base64().decode(sSrc);// 先用base64解密
            try
            {
                byte[] original = cipher.doFinal(encrypted1);
                String originalString = new String(original, "utf-8");
                return originalString;
            }
            catch (Exception e)
            {
                System.out.println(e.toString());
                return null;
            }
        }
        catch (Exception ex)
        {
            System.out.println(ex.toString());
            return null;
        }
    }


    public static void main(String[] args)
            throws Exception {
        /*
         * 此处使用AES-128-ECB加密模式，key需要为16位。
         */
        String cKey = "6ay4dlwd4enjbf90";
        // 需要加密的字串
        String cSrc = "123456";
        System.out.println(cSrc);
        // 加密
        String enString = DesKeyUtil.Encrypt(cSrc, cKey);
        System.out.println("加密后的字串是：" + enString);
        // 解密
        String DeString = DesKeyUtil.Decrypt(enString, cKey);
        System.out.println("解密后的字串是：" + DeString);
    }
}

        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.6</version>
        </dependency>

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

import org.springframework.util.StringUtils;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class AESEncryptUtil {

    /**
     * 加解密密钥, 外部可以
     */
    public static final String AES_DATA_SECURITY_KEY = "4%YkW!@g5LGcf9Ut";
    /**
     * 算法/加密模式/填充方式
     */
    private static final String AES_PKCS5P = "AES/ECB/PKCS5Padding";

    private static final String AES_PERSON_KEY_SECURITY_KEY = "pisnyMyZYXuCNcRd";

    /**
     * 加密
     *
     * @param str
     *            需要加密的字符串
     * @param key
     *            密钥
     * @return
     * @throws Exception
     */
    public static String encrypt(String str, String key) {
        if (StringUtils.isEmpty(key)) {
            throw new RuntimeException("key不能为空");
        }
        try {
            if (str == null) {
                return null;
            }
            // 判断Key是否为16位
            if (key.length() != 16) {
                return null;
            }
            byte[] raw = key.getBytes("UTF-8");
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            // "算法/模式/补码方式"
            Cipher cipher = Cipher.getInstance(AES_PKCS5P);
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
            byte[] encrypted = cipher.doFinal(str.getBytes("UTF-8"));
            // 此处使用BASE64做转码功能，同时能起到2次加密的作用。
            return new BASE64Encoder().encode(encrypted);
        } catch (Exception ex) {
            return null;
        }

    }

    /**
     * 解密
     *
     * @param str 需要解密的字符串
     * @param key 密钥
     * @return
     */
    public static String decrypt(String str, String key) {
        if (StringUtils.isEmpty(key)) {
            throw new RuntimeException("key不能为空");
        }
        try {
            if (str == null) {
                return null;
            }
            // 判断Key是否为16位
            if (key.length() != 16) {
                return null;
            }
            byte[] raw = key.getBytes("UTF-8");
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance(AES_PKCS5P);
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            // 先用base64解密
            byte[] encrypted = new BASE64Decoder().decodeBuffer(str);
            try {
                byte[] original = cipher.doFinal(encrypted);
                String originalString = new String(original, "UTF-8");
                return originalString;
            } catch (Exception e) {
                return null;
            }
        } catch (Exception ex) {
            return null;
        }
    }

    /**
     * 加密
     *
     * @param str 需要加密的字符串
     * @return
     * @throws Exception
     */
    public static String encrypt(String str) {
        return encrypt(str,AES_DATA_SECURITY_KEY);
    }

    /**
     * 解密
     * @param str 需要解密的字符串
     * @return
     */
    public static String decrypt(String str) {
        return decrypt(str,AES_DATA_SECURITY_KEY);
    }

    /**
     * 查询的时候对某些字段解密
     *
     * @param str
     * @return
     */
    public static String aesDecrypt(String str) {
        if (str.isEmpty()) {
            return " ";
        }
        String sql = " AES_DECRYPT(from_base64(" + str + ")," + "'" + AES_DATA_SECURITY_KEY + "')";
        return sql;
    }

    /**
     * 对personKey加密
     *
     * @param personKey
     * @return
     */
    public static String encryptPersonKey(String personKey) {
        return AESEncryptUtil.encrypt(personKey, AES_PERSON_KEY_SECURITY_KEY);
    }

    /**
     * 对personKey解密
     *
     * @param personKey
     * @return
     */
    public static String decryptPersonKey(String personKey) {
        return AESEncryptUtil.decrypt(personKey, AES_PERSON_KEY_SECURITY_KEY);
    }


    public static void main(String... args) {
        //加密
        System.out.println(encrypt("password",AES_DATA_SECURITY_KEY));
        //解密
        System.out.println(decrypt("Kvbdp3xZ3I64KyGHVZzCxQ==",AES_DATA_SECURITY_KEY));
    }
}

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SignatureException;

import org.apache.commons.codec.digest.DigestUtils;

public class MD5Util {
    private static MessageDigest md;

    public static final String KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCvBx/V89FGlf601RmlvkQGHWZ1\n" +
            "ZOx8VsoI4Ss1sh8KXRXftQSwQZYTu/3iGrHLXoUg+FhArpZNdGo3QgaAaCnGpnkp\n" +
            "vWPK/SS1UomvJGuS9ZNYswTO7NYxhtAhrue2BER/9HxGOIyf+RYgVsTti7hPIT+S\n" +
            "A5O4q+sEFwVznjocfwIDAQAB";

    public static final String PRVKEY = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAK8HH9Xz0UaV/rTV\n" +
            "GaW+RAYdZnVk7HxWygjhKzWyHwpdFd+1BLBBlhO7/eIasctehSD4WECulk10ajdC\n" +
            "BoBoKcameSm9Y8r9JLVSia8ka5L1k1izBM7s1jGG0CGu57YERH/0fEY4jJ/5FiBW\n" +
            "xO2LuE8hP5IDk7ir6wQXBXOeOhx/AgMBAAECgYBGj9O42KvVDiF6W7MUS8l2waGN\n" +
            "0Fs6oW6f988Ivb+f2Pk5j+vM9xP+7roizmpBN+Dp8tT5dqknnrg3gMnIOLYmMhp+\n" +
            "9f/amlm/GD8LwBJi1AHzXCSIFpsNnH4i0bT0xw4NmLQb5HSczUO1XPNwi+lLjn5W\n" +
            "JJyPzxqMDstMcz67oQJBAN2NTwgvsku6ncTtuqW6fS/21uFzZzL38AjjodGSJm34\n" +
            "a/fk3YE8WFFEE8UpFbyKtQTKMh652FF6NLIymiyak/ECQQDKPfXkHuZzxJhXyLM6\n" +
            "FKwY1aabnAqwPFYiaUPcSjq89X+KM+7tH3QGHIi4eWwDSdxtMMI9jyOXHv4QT3hm\n" +
            "jmdvAkB81YVliHJ/BxykfIsBnK2zG/OBvuO0LU3bxF9GVYI/zo0Pda51hkoBKEm3\n" +
            "eunbfZB3rXJGK9M+PYx5p9eFMGgRAkAaoaodjgwetoaxGJaxUUOQSaIU36lwp6FY\n" +
            "CrCK86Nkepd+5XPS+c9Xdq5yTFry2+kQ39jULmMrZUNjdnOOXbY1AkBVCLqDf8IB\n" +
            "x73GYvldZUaWAdy1Ix2aLz6WLkRrQWW/iwimlTm8r213K7zXfGUf6/CxzKeK3l7V\n" +
            "oW5LuzQhRU6p";




    /**
     *      * 签名字符串
     *      *
     *      * @param text
     *      *            需要签名的字符串
     *      * @param key
     *      *            密钥
     *      * @param input_charset
     *      *            编码格式
     *      * @return 签名结果
     *     
     */
    public static String sign(String text, String key, String charset) throws Exception {
        text = text + key;
        return DigestUtils.md5Hex(getContentBytes(text, charset));

    }

    /**
     *      * 签名字符串
     *      *
     *      * @param text
     *      *            需要签名的字符串
     *      * @param sign
     *      *            签名结果
     *      * @param key
     *      *            密钥
     *      * @param input_charset
     *      *            编码格式
     *      * @return 签名结果
     *     
     */
    public static boolean verify(String text, String sign, String key, String charset) throws Exception {
        text = text + key;
        String mysign = DigestUtils.md5Hex(getContentBytes(text, charset));
        if (mysign.equals(sign)) {
            return true;
        } else {
            return false;
        }
    }

    /**
     *      * @param content
     *      * @param charset
     *      * @return
     *      * @throws SignatureException
     *      * @throws UnsupportedEncodingException
     *     
     */
    private static byte[] getContentBytes(String content, String charset) {
        if (charset == null || "".equals(charset)) {
            return content.getBytes();
        }
        try {
            return content.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
        }
    }

    /**
     *      * 通联签名
     *      * @param b
     *      * @return
     *     
     */
    public static String computeDigest(byte[] b) {
        try {
            md = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return new String(b);
        }
        md.reset();
        md.update(b);
        byte[] hash = md.digest();
        StringBuffer outStrBuf = new StringBuffer(32);
        for (int i = 0; i < hash.length; i++) {
            int v = hash[i] & 0xFF;
            if (v < 16) {
                outStrBuf.append('0');
            }
            outStrBuf.append(Integer.toString(v, 16).toLowerCase());
        }
        return outStrBuf.toString();
    }

    public static void main(String[] args) {
       String str = "buy_qty=3&coupon_id=sf0001&encoding=UTF-8&gift_mall_no=001&order_no=2020052210001&txnTime=20200522&txn_type=REQ-CPN&user_id=18956315452&user_info=li&version=1.0.0";
        try {
            String strSign = sign(str, KEY, "UTF-8");
            System.out.println("加签结果：" + strSign);

            System.out.println(verify(str, strSign, KEY, "UTF-8"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}