private final static String DES = "DES";


public static void main(String[] args) throws Exception {
        String data = "123 456";
        String key = "wang!@#$";
        System.err.println(encrypt(data, key));
        System.err.println(decrypt(encrypt(data, key), key));


    }


/**
     * Description 根據鍵值進行加密
     * @param data
     * @param key  加密鍵byte數組
     * @return
     * @throws Exception
     */
public static String encrypt(String data, String key) throws Exception {
byte[] bt = encrypt(data.getBytes(), key.getBytes());
        String strs = new BASE64Encoder().encode(bt);
return strs;
    }


/**
     * Description 根據鍵值進行解密
     * @param data
     * @param key  加密鍵byte數組
     * @return
     * @throws IOException
     * @throws Exception
     */
public static String decrypt(String data, String key) throws IOException,
            Exception {
if (data == null)
return null;
        BASE64Decoder decoder = new BASE64Decoder();
byte[] buf = decoder.decodeBuffer(data);
byte[] bt = decrypt(buf,key.getBytes());
return new String(bt);
    }


/**
     * Description 根據鍵值進行加密
     * @param data
     * @param key  加密鍵byte數組
     * @return
     * @throws Exception
     */
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
// 生成一個可信任的隨機數源
        SecureRandom sr = new SecureRandom();


// 從原始密鑰數據創建DESKeySpec對象
        DESKeySpec dks = new DESKeySpec(key);


// 創建一個密鑰工廠，然后用它把DESKeySpec轉換成SecretKey對象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);


// Cipher對象實際完成加密操作
        Cipher cipher = Cipher.getInstance(DES);


// 用密鑰初始化Cipher對象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);


return cipher.doFinal(data);
    }




/**
     * Description 根據鍵值進行解密
     * @param data
     * @param key  加密鍵byte數組
     * @return
     * @throws Exception
     */
private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
// 生成一個可信任的隨機數源
        SecureRandom sr = new SecureRandom();


// 從原始密鑰數據創建DESKeySpec對象
        DESKeySpec dks = new DESKeySpec(key);


// 創建一個密鑰工廠，然后用它把DESKeySpec轉換成SecretKey對象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
        SecretKey securekey = keyFactory.generateSecret(dks);


// Cipher對象實際完成解密操作
        Cipher cipher = Cipher.getInstance(DES);


// 用密鑰初始化Cipher對象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);


return cipher.doFinal(data);
    }

5fiw/XhRJ0E=
123 456

public DESKeySpec(byte[] var1, int var2) throws InvalidKeyException {
    if (var1.length - var2 < 8) {
        throw new InvalidKeyException("Wrong key size");
    } else {
        this.key = new byte[8];
        System.arraycopy(var1, var2, this.key, 0, 8);
    }
}

public static void main(String[] args) throws Exception {
/*
         * 此處使用AES-128-ECB加密模式，key需要為16位。
         */
        String cKey = "1234567890123456";
// 需要加密的字串
        String cSrc = "buxuewushu";
        System.out.println(cSrc);
// 加密
        String enString = Encrypt(cSrc, cKey);
        System.out.println("加密后的字串是：" + enString);


// 解密
        String DeString = Decrypt(enString, cKey);
        System.out.println("解密后的字串是：" + DeString);
    }


// 加密
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;
        }
    }

-- 生成公鑰和私鑰
openssl genrsa -out key.pem 1024
            -out 指定生成文件，此文件包含公鑰和私鑰兩部分，所以即可以加密，也可以解密
1024 生成密鑰的長度

public static KeyPair buildKeyPair() throws NoSuchAlgorithmException {
final int keySize = 2048;
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(RSA_ALGORITHM);
    keyPairGenerator.initialize(keySize);
return keyPairGenerator.genKeyPair();
}

--- 加密
public static byte[] encrypt(PublicKey publicKey, String message) throws Exception {
        Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);


return cipher.doFinal(message.getBytes(UTF8));
    }

--- 解密
public static byte[] decrypt(PrivateKey privateKey, byte [] encrypted) throws Exception {
    Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
    cipher.init(Cipher.DECRYPT_MODE, privateKey);


return cipher.doFinal(encrypted);
}

/**
 * 使用RSA簽名
 */
private static String signWithRSA(String content, PrivateKey privateKey) throws Exception {
    Signature signature = Signature.getInstance("SHA1WithRSA");
    signature.initSign(privateKey);
    signature.update(content.getBytes("utf-8"));
    byte[] signed = signature.sign();
return base64Encode(signed);
}

/**
 * 使用RSA驗簽
 */
private static boolean checkSignWithRSA(String content, PublicKey publicKey,String sign) throws Exception {
    Signature signature = Signature.getInstance("SHA1WithRSA");
    signature.initVerify(publicKey);
    signature.update(content.getBytes("utf-8"));
return signature.verify(base64Decode(sign));
}

30（數據類型結構）21（總長度）30（數據類型）09（長度）06 05 2B 0E 03 02 1A 0500【數據具體類型不清楚-請專家指正】 04 (數據類型) 14 (長度) + SHA1簽名數據

public static void main(String[] args) throws Exception {
    KeyPair keyPair = buildKeyPair();


    byte[] encryptData = encrypt(keyPair.getPublic(), "不學無數");


    System.out.println(String.format("加密后的數據：%s",base64Encode(encryptData)));


    System.out.println(String.format("解密后的數據：%s",new String(decrypt(keyPair.getPrivate(),encryptData),UTF8)));


String context = "加簽的字符串";


String sign = signWithRSA(context, keyPair.getPrivate());


    System.out.println(String.format("生成的簽名：%s",sign));


Boolean checkSignWithRSA = checkSignWithRSA(context, keyPair.getPublic(), sign);


    System.out.println(String.format("校驗的結果：%s",checkSignWithRSA.toString()));
}

加密后的數據：Bi8b4eqEp+rNRhDaij8vVlNwKuICbPJfFmyzmEXKuAgEgzMPb8hAmYiGN+rbUKWeZYJKJd0fiOXv
6YrYqd7fdast/m443qQreRLxdQFScwvCvj9g1YnPzbU2Q/jIwqAPopTyPHNNngBmFki+R/6V4DYt
HA5gniaUMYzynHdD+/W+x8ZYmwiuuS63+7wXqL36aLKe0H50wELOpSn45Gvni8u+5zPIoHV7PBiz
trCnQvne5LxFKDprrS3td1/76qyupFd+Ul3hsd+gjbAyN2MlXcAFMrGVaRkopWwc9hP1BsPvS52q
/8jOVdbeyU9BziVhViz1V0TtGW8bfbEnIStc3Q==
解密后的數據：不學無數
生成的簽名：wvUXtr2UI0tUXmyMTTUBft8oc1dhvtXSBrFFetI5ZoxMm91TbXRWD31Pgqkg72ADxx9TEOAM3Bm1
kyzfBCZZpoq6Y9SM4+jdJ4sMTVtw0wACPglnPDAGs8sG7nnLhXWNQ1Y4pl4ziY6uLxF1TzQLFTxu
NAS7nyljbG69wrb9R3Sv5t8r1I54rYCVGSVFmTrGf+dSCjxABZv6mH8nygVif7zN1vU1+nSDKcON
Vtrpv0xCQHVBqnHPA6OiDm5GzBQxjD5aQt8mfgv8JJrB52TEa4JPYoC5Zw4JHlL++OvPwMpJgnuG
yg5vnWhxE2ncTzM+/pZ+CnXF2Dqv/JMQOfX6tA==
校驗的結果：true

public static String getMD5Str(String str) throws Exception {
try {
// 生成一個MD5加密計算摘要
        MessageDigest md = MessageDigest.getInstance("MD5");
// 計算md5函數
        md.update(str.getBytes());
// digest()最后確定返回md5 hash值，返回值為8為字符串。因為md5 hash值是16位的hex值，實際上就是8位的字符
// BigInteger函數則將8位的字符串轉換成16位hex值，用字符串來表示；得到字符串形式的hash值
return new BigInteger(1, md .digest()).toString(16);
    } catch (Exception e) {
throw new Exception("MD5加密出現錯誤，"+e.toString());
    }
}