一個聚合的加解密工具類

Kakarotto發表於2018-04-11

轉自： https://blog.csdn.net/u013523377/article/details/52755332

小序

字串，byte[]，檔案等物件的加密和解密，是開發當中必不可少的操作。這裡僅基於不同方式的加解密實現，為方便使用固聚合為一個工具類使用，且程式碼實現與前輩們的實現並沒有什麼太大的差別。有需要的親可直接帶走，如若有不正確的地方還望指正。

總覽

function	impact
String md5(String string)	MD5 文字加密
String md5(String string, int times)	MD5 文字多次加密
String md5(String string, String slat)	MD5 文字鹽值加密
String md5(File file, int style)	MD5 檔案 IO/NIO 型別加密
String base64EncodeStr(String string)	Base64 文字加密
String base64DecodedStr(String string)	Base64 文字解密
String base64EncodeFile(File file)	Base64 檔案加密
File base64DecodedFile(String filePath, String code)	Base64 檔案 code 編碼解密
String aes(String content, String password, int type)	AES 加密/解密
String des(String content, String password, int type)	DES 加密/解密
String sha(String string, String type)	SHA 加密
byte[] rsa(byte[] data, String string, int type)	RSA 加密/解密
`Map<String, Object> getKeyPair()`	獲取金鑰（公鑰/私鑰）
`String getKey(Map<String, Object> keyMap, boolean isPublicKey)`	根據上方金鑰獲取公鑰/私鑰
`String sign(byte[] data, String privateKey)`	根據上方私鑰獲取數字簽名
`boolean verify(byte[] data, String publicKey, String sign)`	數字簽名校驗

程式碼

import android.annotation.SuppressLint;
import android.text.TextUtils;
import android.util.Base64;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Signature;
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 java.util.HashMap;
import java.util.Map;

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.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * 加解密工具
 */
public class EncryptUtil {

    private EncryptUtil() {
        throw new UnsupportedOperationException("cannot be instantiated");
    }

    /**
     * 二進位組轉十六進位制字串
     *
     * @param buf 二進位組
     * @return 十六進位制字串
     */
    private static String parseByte2HexStr(byte buf[]) {
        StringBuilder sb = new StringBuilder();
        for (byte b : buf) {
            String hex = Integer.toHexString(b & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 十六進位制字串轉二進位組
     *
     * @param hexStr 十六進位制字串
     * @return 二進位組
     */
    private 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;
    }

    /**
     * MD5加密
     *
     * @param string 加密字串
     * @param slat   加密鹽值key
     * @return 加密結果字串
     */
    public static String md5(String string, String slat) {
        if (TextUtils.isEmpty(string)) return "";

        try {
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            byte[] bytes = md5.digest((string + slat).getBytes());
            String result = "";
            for (byte b : bytes) {
                String temp = Integer.toHexString(b & 0xff);
                if (temp.length() == 1) {
                    temp = "0" + temp;
                }
                result += temp;
            }
            return result;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * MD5加密
     *
     * @param string 加密字串
     * @return 加密結果字串
     * @see #md5(String, String)
     */
    public static String md5(String string) {
        return TextUtils.isEmpty(string) ? "" : md5(string, "");
    }

    /**
     * MD5的IO檔案加密型別
     */
    public static final int MD5_TYPE_IO = 0;

    /**
     * MD5的NIO檔案加密型別
     */
    public static final int MD5_TYPE_NIO = 1;

    /**
     * MD5加密
     *
     * @param file  加密檔案
     * @param style 加密檔案型別：{@link #MD5_TYPE_NIO} ，{@link #MD5_TYPE_IO}
     * @return 加密結果字串
     */
    public static String md5(File file, int style) {
        if (file == null || !file.isFile() || !file.exists()) return "";

        FileInputStream in = null;
        String result = "";
        byte buffer[] = new byte[8192];
        int len;

        try {
            in = new FileInputStream(file);
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            byte[] bytes = md5.digest();

            if (style == MD5_TYPE_IO) {
                while ((len = in.read(buffer)) != -1) {
                    md5.update(buffer, 0, len);
                }
            } else {
                MappedByteBuffer byteBuffer = in.getChannel().map(
                        FileChannel.MapMode.READ_ONLY, 0, file.length());
                md5.update(byteBuffer);
            }

            for (byte b : bytes) {
                String temp = Integer.toHexString(b & 0xff);
                if (temp.length() == 1) {
                    temp = "0" + temp;
                }
                result += temp;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return result;
    }

    /**
     * MD5加密
     *
     * @param string 加密字串
     * @param times  重複加密次數
     * @return 加密結果字串
     */
    public static String md5(String string, int times) {
        if (TextUtils.isEmpty(string)) return "";

        String md5 = md5(string);
        for (int i = 0; i < times; i++) md5 = md5(md5);
        return md5;
    }

    /**
     * Base64加密
     *
     * @param string 加密字串
     * @return 加密結果字串
     */
    public static String base64EncodeStr(String string) {
        if (TextUtils.isEmpty(string)) return "";
        return Base64.encodeToString(string.getBytes(), Base64.DEFAULT);
    }

    /**
     * Base64解密
     *
     * @param string 解密字串
     * @return 解密結果字串
     */
    public static String base64DecodedStr(String string) {
        if (TextUtils.isEmpty(string)) return "";
        return new String(Base64.decode(string, Base64.DEFAULT));
    }

    /**
     * Base64加密
     *
     * @param file 加密檔案
     * @return 加密結果字串
     */
    public static String base64EncodeFile(File file) {
        if (null == file) return "";

        try {
            FileInputStream inputFile = new FileInputStream(file);
            byte[] buffer = new byte[(int) file.length()];
            inputFile.read(buffer);
            inputFile.close();
            return Base64.encodeToString(buffer, Base64.DEFAULT);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * Base64解密
     *
     * @param filePath 解密檔案路徑
     * @param code     解密檔案編碼
     * @return 解密結果檔案
     */
    public static File base64DecodedFile(String filePath, String code) {
        if (TextUtils.isEmpty(filePath) || TextUtils.isEmpty(code)) {
            return null;
        }

        File desFile = new File(filePath);
        try {
            byte[] decodeBytes = Base64.decode(code.getBytes(), Base64.DEFAULT);
            FileOutputStream fos = new FileOutputStream(desFile);
            fos.write(decodeBytes);
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return desFile;
    }

    /**
     * Aes加密/解密
     *
     * @param content  字串
     * @param password 金鑰
     * @param type     加密：{@link Cipher#ENCRYPT_MODE}，解密：{@link Cipher#DECRYPT_MODE}
     * @return 加密/解密結果字串
     */
    public static String aes(String content, String password, int type) {
        try {
            KeyGenerator generator = KeyGenerator.getInstance("AES");
            SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG", "Crypto");
            secureRandom.setSeed(password.getBytes());
            generator.init(128, secureRandom);
            SecretKey secretKey = generator.generateKey();
            byte[] enCodeFormat = secretKey.getEncoded();
            SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
            @SuppressLint("GetInstance") Cipher cipher = Cipher.getInstance("AES");
            cipher.init(type, key);

            if (type == Cipher.ENCRYPT_MODE) {
                byte[] byteContent = content.getBytes("utf-8");
                return parseByte2HexStr(cipher.doFinal(byteContent));
            } else {
                byte[] byteContent = parseHexStr2Byte(content);
                return new String(cipher.doFinal(byteContent));
            }
        } catch (NoSuchAlgorithmException | BadPaddingException | IllegalBlockSizeException |
                UnsupportedEncodingException | InvalidKeyException | NoSuchPaddingException |
                NoSuchProviderException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Des加密/解密
     *
     * @param content  字串內容
     * @param password 金鑰
     * @param type     加密：{@link Cipher#ENCRYPT_MODE}，解密：{@link Cipher#DECRYPT_MODE}
     * @return 加密/解密結果
     */
    public static String des(String content, String password, int type) {
        try {
            SecureRandom random = new SecureRandom();
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            @SuppressLint("GetInstance") Cipher cipher = Cipher.getInstance("DES");
            cipher.init(type, keyFactory.generateSecret(desKey), random);

            if (type == Cipher.ENCRYPT_MODE) {
                byte[] byteContent = content.getBytes("utf-8");
                return parseByte2HexStr(cipher.doFinal(byteContent));
            } else {
                byte[] byteContent = parseHexStr2Byte(content);
                return new String(cipher.doFinal(byteContent));
            }
        } catch (NoSuchAlgorithmException | BadPaddingException | IllegalBlockSizeException |
                UnsupportedEncodingException | InvalidKeyException | NoSuchPaddingException |
                InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * Sha加密型別
     */
    public final static String SHA224 = "sha-224";

    /**
     * Sha加密型別
     */
    public final static String SHA256 = "sha-256";

    /**
     * Sha加密型別
     */
    public final static String SHA384 = "sha-384";

    /**
     * Sha加密型別
     */
    public final static String SHA512 = "sha-512";

    /**
     * Sha加密
     *
     * @param string 加密字串
     * @param type   加密型別 ：{@link #SHA224}，{@link #SHA256}，{@link #SHA384}，{@link #SHA512}
     * @return SHA加密結果字串
     */
    public static String sha(String string, String type) {
        if (TextUtils.isEmpty(string)) return "";
        if (TextUtils.isEmpty(type)) type = SHA256;

        try {
            MessageDigest md5 = MessageDigest.getInstance(type);
            byte[] bytes = md5.digest((string).getBytes());
            String result = "";
            for (byte b : bytes) {
                String temp = Integer.toHexString(b & 0xff);
                if (temp.length() == 1) {
                    temp = "0" + temp;
                }
                result += temp;
            }
            return result;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 隨機獲取金鑰(公鑰和私鑰), 客戶端公鑰加密，伺服器私鑰解密
     *
     * @return 結果金鑰對
     * @throws Exception
     */
    public static Map<String, Object> getKeyPair() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", "BC");
        keyPairGen.initialize(1024);

        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<>(2);
        keyMap.put("RSAPublicKey", publicKey);
        keyMap.put("RSAPrivateKey", privateKey);
        return keyMap;
    }

    /**
     * 獲取公鑰/私鑰
     *
     * @param keyMap      金鑰對
     * @param isPublicKey true：獲取公鑰，false：獲取私鑰
     * @return 獲取金鑰字串
     */
    public static String getKey(Map<String, Object> keyMap, boolean isPublicKey) {
        Key key = (Key) keyMap.get(isPublicKey ? "RSAPublicKey" : "RSAPrivateKey");
        return new String(Base64.encode(key.getEncoded(), Base64.DEFAULT));
    }

    /**
     * 獲取數字簽名
     *
     * @param data       二進位制位
     * @param privateKey 私鑰(BASE64編碼)
     * @return 數字簽名結果字串
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = Base64.decode(privateKey.getBytes(), Base64.DEFAULT);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA", "BC");
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(privateK);
        signature.update(data);
        return new String(Base64.encode(signature.sign(), Base64.DEFAULT));
    }

    /**
     * 數字簽名校驗
     *
     * @param data      二進位組
     * @param publicKey 公鑰(BASE64編碼)
     * @param sign      數字簽名字串
     * @return true：校驗成功，false：校驗失敗
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        byte[] keyBytes = Base64.decode(publicKey.getBytes(), Base64.DEFAULT);

        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA", "BC");
        PublicKey publicK = keyFactory.generatePublic(keySpec);

        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initVerify(publicK);
        signature.update(data);
        return signature.verify(Base64.decode(sign.getBytes(), Base64.DEFAULT));
    }

    /**
     * Rsa公鑰加密型別
     */
    public static final int RSA_PUBLIC_ENCRYPT = 0;

    /**
     * Rsa公鑰解密型別
     */
    public static final int RSA_PUBLIC_DECRYPT = 1;

    /**
     * Rsa私鑰加密型別
     */
    public static final int RSA_PRIVATE_ENCRYPT = 2;

    /**
     * Rsa私鑰解密型別
     */
    public static final int RSA_PRIVATE_DECRYPT = 3;

    /**
     * Rsa加密/解密（一般情況下，公鑰加密私鑰解密）
     *
     * @param data   源資料
     * @param string 金鑰(BASE64編碼)
     * @param type   操作型別：{@link #RSA_PUBLIC_ENCRYPT}，{@link #RSA_PUBLIC_DECRYPT}，{@link #RSA_PRIVATE_ENCRYPT}，{@link #RSA_PRIVATE_DECRYPT}
     * @return 加密/解密結果字串
     * @throws Exception
     */
    public static byte[] rsa(byte[] data, String string, int type) throws Exception {
        byte[] keyBytes = Base64.decode(string, Base64.DEFAULT);

        Key key;
        KeyFactory keyFactory = KeyFactory.getInstance("RSA", "BC");
        if (type == RSA_PUBLIC_ENCRYPT || type == RSA_PUBLIC_DECRYPT) {
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
            key = keyFactory.generatePublic(x509KeySpec);
        } else {
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
            key = keyFactory.generatePrivate(pkcs8KeySpec);
        }

        // 對資料加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;

        // 對資料分段加密
        if (type == RSA_PUBLIC_ENCRYPT || type == RSA_PRIVATE_ENCRYPT) {
            cipher.init(Cipher.ENCRYPT_MODE, key);

            while (inputLen - offSet > 0) {
                cache = cipher.doFinal(data, offSet, inputLen - offSet > 117 ? 117 : inputLen - offSet);
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * 117;
            }
        } else {
            cipher.init(Cipher.DECRYPT_MODE, key);

            while (inputLen - offSet > 0) {
                if (inputLen - offSet > 128) {
                    cache = cipher.doFinal(data, offSet, 128);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * 128;
            }
        }
        byte[] result = out.toByteArray();
        out.close();
        return result;
    }
}
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538複製程式碼

實現

md5

// 字串加密
String str = "123456";
System.out.println("一次加密：" + Encryption.md5(str));
System.out.println("二次加密：" + Encryption.md5(str, 2));
System.out.println("鹽值加密：" + Encryption.md5(str, "78"));12345複製程式碼

System.out: 一次加密：e10adc3949ba59abbe56e057f20f883e
System.out: 二次加密：c56d0e9a7ccec67b4ea131655038d604
System.out: 鹽值加密：25d55ad283aa400af464c76d713c07ad

// 檔案加密
Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
System.out.println("IO檔案加密：" + EncryptUtil.md5(getBitmap2File(bmp), EncryptUtil.MD5_TYPE_IO));
System.out.println("NIO檔案加密：" + EncryptUtil.md5(getBitmap2File(bmp), EncryptUtil.MD5_TYPE_NIO));1234複製程式碼

I/System.out: IO檔案加密：d41d8cd98f00b204e9800998ecf8427e
I/System.out: NIO檔案加密：d41d8cd98f00b204e9800998ecf8427e

Base64

// 字串加解密
String baseStr = EncryptUtil.base64EncodeStr("123456");
System.out.println("base64字串加密：" + baseStr);
System.out.println("base64字串解密：" + EncryptUtil.base64DecodedStr(baseStr));1234複製程式碼

I/System.out: base64字串加密：MTIzNDU2
I/System.out: base64字串解密：123456

// 檔案加解密
Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.mipmap.ic_launcher);
String baseFile = EncryptUtil.base64EncodeFile(getBitmap2File(bmp));
System.out.println("base64檔案加密：" + baseFile);
System.out.println("base64檔案解密：" + EncryptUtil.base64DecodedFile("/mnt/sdcard/01.jpg", baseFile));12345複製程式碼

I/System.out: base64檔案加密：
/9j/4AAQSkZJRgABAQAAAQABAAD/2wBDAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB
…
I/System.out: base64檔案解密：/mnt/sdcard/01.jpg

AES

// 物件加解密
String key = "1234567890123456";
String aesStr = EncryptUtil.aes("gzejia", key, Cipher.ENCRYPT_MODE);
System.out.println("aes物件加密： " + aesStr);
System.out.println("aes物件解密： " + EncryptUtil.aes(aesStr, key, Cipher.DECRYPT_MODE));12345複製程式碼

I/System.out: aes物件加密： 7E8886393DD34B24CC51B1A9D030DB5A
I/System.out: aes物件解密： gzejia

javax.crypto.BadPaddingException: pad block corrupted

，出現該異常的主導原因可能如下：

金鑰key長度不足16位
缺少 SecureRandom secureRandom = SecureRandom.getInstance(“SHA1PRNG”, “Crypto”);

DES

String key = "1234567890123456";
String desStr = EncryptUtil.des("gzejia", key, Cipher.ENCRYPT_MODE);
System.out.println("des物件加密： " + desStr);
System.out.println("des物件解密： " + EncryptUtil.des(desStr, key, Cipher.DECRYPT_MODE));1234複製程式碼

I/System.out: des物件加密： 552E6962E5187580
I/System.out: des物件解密： gzejia

SHA

String shaStr = "gzejia";
System.out.println("sha_SHA224物件加密： " + EncryptUtil.sha(shaStr, EncryptUtil.SHA224));
System.out.println("sha_SHA256物件加密： " + EncryptUtil.sha(shaStr, EncryptUtil.SHA256));
System.out.println("sha_SHA384物件加密： " + EncryptUtil.sha(shaStr, EncryptUtil.SHA384));
System.out.println("sha_SHA512物件加密： " + EncryptUtil.sha(shaStr, EncryptUtil.SHA512));12345複製程式碼

I/System.out: sha_SHA224物件加密：
36e2a37256a87dda91e8dacf9662c49461ecfc68d65488857c146e59
I/System.out: sha_SHA256物件加密：
94a9222df72d5927d1996203b0b186ab857d9055db54b48277bf943272b19fc1
I/System.out: sha_SHA384物件加密：
ea8e751bdfccb96715a37153a831fc935e2986743de72b32941043c1960f2e2ab7d71b965dda42cd128a837191e4667a
I/System.out: sha_SHA512物件加密：
a5e7bea71af1fccdc1f3d353df08013e2bebe8e0a49b435512bdc855f36589cffbf1ac1825e2357a4a4f8b5295173928f76a806ba0c77c2a7ba3ef068cdf3ced

RSA

try {
    byte[] data = "gzejia有中文".getBytes();

    // 金鑰與數字簽名獲取
    Map<String, Object> keyMap = EncryptUtil.getKeyPair();
    String publicKey = EncryptUtil.getKey(keyMap, true);
    System.out.println("rsa獲取公鑰： " + publicKey);
    String privateKey = EncryptUtil.getKey(keyMap, false);
    System.out.println("rsa獲取私鑰： " + privateKey);

    // 公鑰加密私鑰解密
    byte[] rsaPublic =
            EncryptUtil.rsa(data, publicKey, EncryptUtil.RSA_PUBLIC_ENCRYPT);
    System.out.println("rsa公鑰加密： " + new String(rsaPublic));
    System.out.println("rsa私鑰解密： " + new String(
            EncryptUtil.rsa(rsaPublic, privateKey, EncryptUtil.RSA_PRIVATE_DECRYPT)));

    // 私鑰加密公鑰解密
    byte[] rsaPrivate =
            EncryptUtil.rsa(data, privateKey, EncryptUtil.RSA_PRIVATE_ENCRYPT);
    System.out.println("rsa私鑰加密： " + new String(rsaPrivate));
    System.out.println("rsa公鑰解密： " + new String(
            EncryptUtil.rsa(rsaPrivate, publicKey, EncryptUtil.RSA_PUBLIC_DECRYPT)));

    // 私鑰簽名及公鑰簽名校驗
    String signStr = EncryptUtil.sign(rsaPrivate, privateKey);
    System.out.println("rsa數字簽名生成： " + signStr);
    System.out.println("rsa數字簽名校驗： " +
            EncryptUtil.verify(rsaPrivate, publicKey, signStr));
} catch (Exception e) {
    e.printStackTrace();
}1234567891011121314151617181920212223242526272829303132複製程式碼

I/System.out: rsa獲取公鑰：
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC3W84EWgATxN4OfjXUResyzy+lf/8TDDmHtRkh
…
I/System.out: rsa獲取私鑰：
MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBALdbzgRaABPE3g5+NdRF6zLPL6V/
…
I/System.out: rsa公鑰加密：o�ZW�Ay��&�d��qa�h�]�ɟ�Ӵ�Rg1�0#
…
I/System.out: rsa私鑰解密： gzejia有中文
I/System.out: rsa私鑰加密： � ��IA�{�R�+�y�_��%�=��
…
I/System.out: rsa公鑰解密： gzejia有中文
I/System.out: rsa數字簽名生成：
XYHhwM2d+qUOWfTvi4l0Xh0JHlgf4zOBz81wahV90dxHhoqbi/HG6PlmkPnFnnZAkB5X8VMRKumK
…
I/System.out: rsa數字簽名校驗： true

java.security.spec.InvalidKeySpecException:
java.lang.RuntimeException: error:0D0680A8:asn1 encoding routines:ASN1_CHECK_TLEN:wrong tag，解決途徑：

原語句： KeyFactory keyf = KeyFactory.getInstance(“RSA”);
更改為：KeyFactory keyFactory = KeyFactory.getInstance(“RSA”, “BC”);

場景普及

對稱加密

加密和解密用的是同一個金鑰

非對稱加密

金鑰對（即公鑰與私鑰），分別負責加密或解密的任務

非對稱加密+對稱加密

主對稱加密，以非對稱加密方式傳輸對稱加密金鑰

vue 核心加解密工具類方法
2021-12-28
Vue解密
常用加解密工具類（MD5、SHA、DES、AES、RSA）
2016-01-22
解密
LruCache-一個工具類
2019-08-09
手寫一個LRU工具類
2021-05-11
一個struct聚合的問題
2017-07-14
Struct
一個比較float是否相等的工具類
2021-07-21
推薦一個java操作ftp的工具類
2019-01-19
JavaFTP
Java類方法(定義一個工具類,儲存一些常用的方法)
2020-10-19
Java
Android 擼一個快取工具類
2018-07-19
Android快取
一個工具類草根網站的失敗教訓
2013-07-01
網站
寫了一個 SRE 除錯工具，類似一個小木馬
2024-04-18
除錯
三個好用的併發工具類
2019-03-02
介紹幾個好用的工具類
2022-01-09
工具篇：介紹幾個好用的guava工具類
2021-06-18
Guava
常用的一些工具類
2018-03-31
寫一個工具生成資料庫實體類
2019-02-02
資料庫
java的一個類！
2016-03-17
Java
c++類與類的聚合(Aggregation)關係
2020-10-29
C++
HExcel，一個簡單通用的匯入匯出Excel工具類
2023-10-30
Excel
windows forms 上一個類似於wpf snoop 的工具: Hawkeye
2014-10-14
WindowsORMOOP
從零開始實現一個MyBatis加解密外掛
2022-08-23
MyBatis解密
Java開發常用的16個工具類
2020-11-18
Java
實現一個CRDT工具庫——VClock 時鐘向量類
2023-03-26
[apue] 一個快速確定新系統上各類限制值的工具
2020-06-17
一個工具類實現自定義Tablayout的下劃線寬度
2018-07-19
TabLayout
我寫了一個從DATASOURCE取得CONNECTION的工具類，大家看看
2004-03-20
搭建一個Java專案可直接拿去使用的通用工具類
2024-03-09
Java
使用Apache的Base64類實現Base64加解密
2016-11-16
Apache解密
前端常用的 59 個工具類【持續更新】
2019-12-03
前端
一個分數類的實現——Rational類
2018-02-15
Model類的一個return作用
2019-05-11
一個Java類的載入
2021-05-31
Java
簡潔優雅的內容聚合工具-feedly
2016-03-13
(持續更新, 目前含100+工具類) DevUtils 是一個 Android 工具庫
2019-03-15
devAndroid
分享一個自然語言漢語時間語義識別的工具類
2020-11-09
實現一個具有百度文庫文件轉換功能的工具類
2012-02-07
【Java加解密系列】- SM2加解密
2020-12-01
Java解密
配置簡單功能強大的excel工具類搞定excel匯入匯出工具類(一)
2012-09-22
Excel