安全算法demo

一些常用的安全加密解码代码

package com.bogle.nio;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * Created by lenovo on 2017/4/4.
 */
public class Digest {


    //--------------------------------------------------------------------------------数值摘要----------------------------------------------------------------------

    /**
     * md5加密
     *
     * @param content
     * @return
     * @throws Exception
     */
    public static byte[] md5(String content) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] bytes = md.digest(content.getBytes("utf8"));
        return bytes;
    }


    /**
     * sha1加密
     *
     * @param content
     * @return
     * @throws Exception
     */
    public static byte[] sha1(String content) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA-1");
        byte[] bytes = md.digest(content.getBytes("utf8"));
        return bytes;
    }

    /**
     * bytes 转十六进制
     *
     * @param bytes
     * @return
     */
    public static String bytes2Hex(byte[] bytes) {
        StringBuilder hex = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            byte b = bytes[i];
            boolean negative = false;//是否为负数
            if (b < 0) negative = true;
            int inte = Math.abs(b);
            if (negative) inte = inte | 0x80;//负数会转成整数（最高位的符号变成数值计算），在转十六进制
            String temp = Integer.toHexString(inte & 0xFF);
            if (temp.length() == 1) {
                hex.append(0);
            }
            hex.append(temp.toLowerCase());
        }
        return hex.toString();
    }

    /**
     * 十六进制转bytes
     *
     * @param hex
     * @return
     */
    public static byte[] hex2Bytes(String hex) {
        byte[] bytes = new byte[hex.length() / 2];
        for (int i = 0; i < hex.length(); i = i + 2) {
            String subStr = hex.substring(i, i + 2);
            boolean negative = false; //是否为负数
            int inte = Integer.parseInt(subStr, 16);
            if (inte > 127) negative = true;
            if (inte == 128) {
                inte = -128;
            } else if (negative) {
                inte = 0 - (inte & 0x7F);
            }
            byte b = (byte) inte;
            bytes[i / 2] = b;
        }
        return bytes;
    }

    /**
     * byte转base64
     *
     * @param bytes
     * @return
     */
    public static String byte2base64(byte[] bytes) {
        BASE64Encoder base64Encoder = new BASE64Encoder();
        return base64Encoder.encode(bytes);
    }

    /**
     * base64转bytes
     *
     * @param base64
     * @return
     * @throws IOException
     */
    public static byte[] base642byte(String base64) throws IOException {
        BASE64Decoder base64Decoder = new BASE64Decoder();
        return base64Decoder.decodeBuffer(base64);
    }

    //--------------------------------------------------------------------------------对称加密----------------------------------------------------------------------

    //////////////////////////////////////////////////////////DES加密解密/////////////////////////////////////

    /**
     * 生产DES密钥
     *
     * @return
     * @throws Exception
     */
    public static String getKeyDES() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("DES");
        keyGen.init(56);
        SecretKey key = keyGen.generateKey();
        String base64Str = byte2base64(key.getEncoded());
        return base64Str;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(getKeyDES());
    }

    public static SecretKey loadKeyDES(String base64Key) throws Exception {
        byte[] bytes = base642byte(base64Key);
        SecretKey key = new SecretKeySpec(bytes, "DES");
        return key;
    }

    /**
     * DES加密
     *
     * @param source
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptDES(byte[] source, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] bytes = cipher.doFinal(source);
        return bytes;
    }

    /**
     * DES解密
     *
     * @param source
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptDES(byte[] source, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] bytes = cipher.doFinal(source);
        return bytes;
    }

    //////////////////////////////////////////////////////////AES加密解密/////////////////////////////////////

    /**
     * 生成AES密钥
     *
     * @return
     * @throws Exception
     */
    public static String genKeyAES() throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(128);
        SecretKey key = keyGen.generateKey();
        String base64Str = byte2base64(key.getEncoded());
        return base64Str;
    }

    public static SecretKey loadKeyAES(String base64Key) throws Exception {
        byte[] bytes = base642byte(base64Key);
        SecretKey key = new SecretKeySpec(bytes, "AES");
        return key;
    }

    /**
     * AES加密
     *
     * @param source
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] encryptAES(byte[] source, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] bytes = cipher.doFinal(source);
        return bytes;
    }

    /**
     * AES解密
     *
     * @param source
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptAES(byte[] source, SecretKey key) throws Exception {
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] bytes = cipher.doFinal(source);
        return bytes;
    }

    //--------------------------------------------------------------------------------非对称加密----------------------------------------------------------------------

    /**
     * 生成公钥和私钥
     *
     * @return
     * @throws Exception
     */
    public static KeyPair getKeyPair() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(512);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        return keyPair;
    }

    public static String getPublicKey(KeyPair keyPair) {
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return byte2base64(bytes);
    }

    public static String getPrivateKey(KeyPair keyPair) {
        PublicKey publicKey = keyPair.getPrivate()
        byte[] bytes = publicKey.getEncoded();
        return byte2base64(bytes);
    }

    /**
     * 将String类型的密钥转换为PublicKey
     *
     * @param pubStr
     * @return
     * @throws Exception
     */
    public static PublicKey string2PublicKey(String pubStr) throws Exception {
        byte[] keyBytes = base642byte(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }

    /**
     * 将String类型的密钥转换为privateKey
     *
     * @param priStr
     * @return
     * @throws Exception
     */
    public static PrivateKey string2PrivateKey(String priStr) throws Exception {
        byte[] keyBytes = base642byte(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 使用公钥加密
     *
     * @param content
     * @param publicKey
     * @return
     * @throws Exception
     */
    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }

    /**
     * 使用私钥解密
     *
     * @param content
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }


    //--------------------------------------------------------------------------------MD5withRSA----------------------------------------------------------------------

    /**
     * MD5withRSA算法实现
     * 签名
     *
     * @param content
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] sign(byte[] content, PrivateKey privateKey) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] bytes = md.digest(content);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] encryptBytes = cipher.doFinal(bytes);
        return encryptBytes;
    }

    /**
     * 验证签名是否正确
     * @param content       内容
     * @param sign          签名
     * @param publicKey     公钥
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] content, byte[] sign, PublicKey publicKey) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] bytes = md.digest(content);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] decryptBytes = cipher.doFinal(sign);
        return byte2base64(decryptBytes).equals(byte2base64(bytes));
    }
   
    //基于Signature API的使用
    public static byte[] sign(byte[] content, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(privateKey);
        signature.update(content);
        return signature.sign();
    }

    public static boolean verify(byte[] content, byte[] sign, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    }

    //--------------------------------------------------------------------------------SH1withRSA----------------------------------------------------------------------

    /**
     * sh1签名
     * @param content
     * @param privateKey
     * @return
     * @throws Exception
     */
    public static byte[] sign(byte[] content, PrivateKey privateKey) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA1");
        byte[] bytes = md.digest(content);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] encryptBytes = cipher.doFinal(bytes);
        return encryptBytes;
    }

    /**
     * 验证签名是否正确
     * @param content       内容
     * @param sign          签名
     * @param publicKey     公钥
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] content, byte[] sign, PublicKey publicKey) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA1");
        byte[] bytes = md.digest(content);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] decryptBytes = cipher.doFinal(sign);
        return byte2base64(decryptBytes).equals(byte2base64(bytes));
    }

    //基于Signature API的使用
    public static byte[] sign(byte[] content, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("SHA1withRSA");
        signature.initSign(privateKey);
        signature.update(content);
        return signature.sign();
    }

    public static boolean verify(byte[] content, byte[] sign, PublicKey publicKey) throws Exception {
        Signature signature = Signature.getInstance("SHA1withRSA");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    }
}