目錄
android des加密string：
國密算法，明文、密文、密碼、密鑰、對稱加密、非對稱加密簡單了解
android des加密string：
package com.example.ceshi;
import android.util.Log;
import com.blankj.utilcode.util.StringUtils;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
/**
* @ProjectName: ceshi
* @Package: com.example.ceshi
* @ClassName: DESEncryptUtil
* @Description: java類作用描述
* @Author: 作者名
* @CreateDate: 2020/7/20 0020 下午 4:14
* @UpdateUser: 更新者：
* @UpdateDate: 2020/7/20 0020 下午 4:14
*/
public class DESEncryptUtil {
public static final String PASS_WORD = "f7f0f67e45";
private static SecretKeyFactory keyFactory = null;
private static Cipher cipher = null;
static {
try {
keyFactory = SecretKeyFactory.getInstance("DES");
} catch (Exception e) {
keyFactory = null;
}
try {
cipher = Cipher.getInstance("DES");
} catch (Exception e) {
cipher = null;
}
}
/**
* DES加密
*
* @param password 密碼，長度要是8的倍數
* @return
*/
public static String encrypt(String data, String password) throws Exception {
try {
SecureRandom random = new SecureRandom();
DESKeySpec desKey = new DESKeySpec(password.getBytes());
// 建立一個密匙工廠，然後用它把DESKeySpec轉換成
if (keyFactory == null)
keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey securekey = keyFactory.generateSecret(desKey);
// Cipher對象實際完成加密操作
if (cipher == null)
cipher = Cipher.getInstance("DES");
// 用密匙初始化Cipher對象
cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
// 現在，擷取資料并加密
// 正式執行加密操作
return ByteStringConvertUtil.byte2HexStr(cipher.doFinal(data.getBytes()));
} catch (Exception e) {
throw new Exception("DES解密失敗!");
}
}
public static String decrypt(String data, String password) throws Exception {
try {
// DES算法要求有一個可信任的随機數源
SecureRandom random = new SecureRandom();
// 建立一個DESKeySpec對象
DESKeySpec desKey = new DESKeySpec(password.getBytes());
// 建立一個密匙工廠
if (keyFactory == null)
keyFactory = SecretKeyFactory.getInstance("DES");
// 将DESKeySpec對象轉換成SecretKey對象
SecretKey securekey = keyFactory.generateSecret(desKey);
// Cipher對象實際完成解密操作
if (cipher == null)
cipher = Cipher.getInstance("DES");
// 用密匙初始化Cipher對象
cipher.init(Cipher.DECRYPT_MODE, securekey, random);
// 真正開始解密操作
return new String(cipher.doFinal(ByteStringConvertUtil.hexStr2Byte(data)));
} catch (Exception e) {
throw new Exception("DES解密失敗!");
}
}
} package com.example.ceshi;
public class ByteStringConvertUtil {
/**
* 字元串轉換為位元組資料
*
* @param hexStr
* @return
*/
public static byte[] hexStr2Byte(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;
}
/**
* 位元組數組轉換為字元串
*
* @param buf
* @return
*/
public static String byte2HexStr(byte buf[]) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < buf.length; i++) {
String hex = Integer.toHexString(buf[i] & 255);
if (hex.length() == 1)
hex = (new StringBuilder(String.valueOf('0'))).append(hex).toString();
sb.append(hex.toLowerCase());
}
return sb.toString();
}
} 測試代碼：
@Test
public void ceshia() throws Exception {
String s = "a77a7aaaa";
byte [] data_Voucherno=s.getBytes();
if(data_Voucherno.length % 8 != 0){ //not a multiple of 8
//create a new array with a size which is a multiple of 8
byte[] padded = new byte[data_Voucherno.length + 8 - (data_Voucherno.length % 8)];
//copy the old array into it
System.arraycopy(data_Voucherno, 0, padded, 0, data_Voucherno.length);
data_Voucherno = padded;
}
String key = "CCIC2020";
String data=DESEncryptUtil.encrypt(s,key);
String undata=DESEncryptUtil.decrypt(data,key);
System.out.println(data+11);
System.out.println(undata+11);
} 還有一種：
package com.example.ceshi;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
/**
* @ProjectName: ceshi
* @Package: com.example.ceshi
* @ClassName: Des
* @Description: java類作用描述
* @Author: 作者名
* @CreateDate: 2020/7/20 0020 下午 4:01
* @UpdateUser: 更新者：
* @UpdateDate: 2020/7/20 0020 下午 4:01
*/
public class Des {
/**
* 加密（使用DES算法）
*
* @param txt
* 需要加密的文本
* @param key
* 密鑰
* @return 成功加密的文本
* @throws InvalidKeySpecException
* @throws InvalidKeyException
* @throws NoSuchPaddingException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
public static String enCrypto(String txt, String key)
throws InvalidKeySpecException, InvalidKeyException,
NoSuchPaddingException, IllegalBlockSizeException,
BadPaddingException {
StringBuffer sb = new StringBuffer();
DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
SecretKeyFactory skeyFactory = null;
Cipher cipher = null;
try {
skeyFactory = SecretKeyFactory.getInstance("DES");
cipher = Cipher.getInstance("DES");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey deskey = skeyFactory.generateSecret(desKeySpec);
cipher.init(Cipher.ENCRYPT_MODE, deskey);
byte[] cipherText = cipher.doFinal(txt.getBytes());
for (int n = 0; n < cipherText.length; n++) {
String stmp = (java.lang.Integer.toHexString(cipherText[n] & 0XFF));
if (stmp.length() == 1) {
sb.append("0" + stmp);
} else {
sb.append(stmp);
}
}
return sb.toString().toUpperCase();
}
/**
* 解密（使用DES算法）
*
* @param txt
* 需要解密的文本
* @param key
* 密鑰
* @return 成功解密的文本
* @throws InvalidKeyException
* @throws InvalidKeySpecException
* @throws NoSuchPaddingException
* @throws IllegalBlockSizeException
* @throws BadPaddingException
*/
public static String deCrypto(String txt, String key)
throws InvalidKeyException, InvalidKeySpecException,
NoSuchPaddingException, IllegalBlockSizeException,
BadPaddingException {
DESKeySpec desKeySpec = new DESKeySpec(key.getBytes());
SecretKeyFactory skeyFactory = null;
Cipher cipher = null;
try {
skeyFactory = SecretKeyFactory.getInstance("DES");
cipher = Cipher.getInstance("DES");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
SecretKey deskey = skeyFactory.generateSecret(desKeySpec);
cipher.init(Cipher.DECRYPT_MODE, deskey);
byte[] btxts = new byte[txt.length() / 2];
for (int i = 0, count = txt.length(); i < count; i += 2) {
btxts[i / 2] = (byte) Integer.parseInt(txt.substring(i, i + 2), 16);
}
return (new String(cipher.doFinal(btxts)));
}
public static void main(String[] args) throws InvalidKeyException,
NoSuchAlgorithmException, InvalidKeySpecException,
NoSuchPaddingException, IllegalBlockSizeException,
BadPaddingException {
String soureTxt = "這裡是要加密的文本内容";
String key = "這裡是自定義的密鑰";
String str = null;
System.out.println("明文：" + soureTxt);
str = enCrypto(soureTxt, key);
System.out.println("加密：" + str);
System.out.println("解密：" + deCrypto(str, key));
System.out.println(str + "====" + key);
}
} 國密算法，明文、密文、密碼、密鑰、對稱加密、非對稱加密簡單了解
國密算法是什麼？
國密算法是由國家密碼局釋出，包含SM1、SM2、 SM3、 SM4、 SSF33算法。
國際算法是什麼？
國際算法由美國的安全局釋出，是現今最通用的商用算法。
密碼學中應用最為廣泛算法都有哪些？
密碼學中應用最為廣泛的的三類算法：
1、對稱算法（分組密碼算法）代表分組密碼算法(DES和SM4)；
2、非對稱算法（公鑰密碼算法）代表公鑰密碼算法(RSA和SM2)；
3、雜湊算法（摘要算法）代表摘要算法(HAS-256系列和SM3)；
pin密文是1.1+1.2
1+2=3，最後1和2進行二進制異或，3出表示07 和密碼是什麼後面異或
主密加密工密，工密加密密碼
密碼加密就好比，方程式，也可以說實一種投影，就是密碼通過工作密碼進行加密進行傳輸，好比密碼是x，密鑰是參數y通過方程式運算得出z：就是密文。反向地邏輯就是解密。
還有主密鑰，就是加密工作密鑰，這時候，工作密鑰是x，通過方程式輸出y：是工作密鑰的密文，這樣的話密碼的安全程度就會更高。
我的 了解就是将其了解成為方程式，
des，3des，sm2，sm4，rsa都是加密形式，好比不同函數，不同次元的方程式。
期間的運算是通過，二進制資料，進行移位，補位，進行異或，與，非運算進行加密，生成密文。
明文就是你的密碼了。
密碼(cipher)
密碼學中的密碼（cipher）和我們日常生活中所說的密碼不太一樣，計算機術語『密碼 cipher』是一種用于加密或者解密的算法，而我們日常所使用的『密碼 password』是一種密碼，它是用于認證用途的一組文本字元串，這裡我們要讨論的是前者：cipher。 密鑰(key)
密鑰是一種參數，它是在使用密碼（cipher）算法過程中輸入的參數。同一個明文在相同的密碼算法和不同的密鑰計算下會産生不同的密文。很多知名的密碼算法都是公開的，密鑰才是決定密文是否安全的重要參數，通常密鑰越長，破解的難度越大，比如一個8位的密鑰最多有256種情況，使用窮舉法，能非常輕易的破解，知名的DES算法使用56位的密鑰，目前已經不是一種安全的加密算法了，主要還是因為56位的密鑰太短，在數小時内就可以被破解。密鑰分為對稱密鑰與非對稱密鑰。 明文/密文
明文（plaintext）是加密之前的原始資料，密文是通過密碼（cipher）運算後得到的結果成為密文（ciphertext） 對稱密鑰
對稱密鑰（Symmetric-key algorithm）又稱為共享密鑰加密，對稱密鑰在加密和解密的過程中使用的密鑰是相同的，常見的對稱加密算法有DES、3DES、AES、RC5、RC6。對稱密鑰的優點是計算速度快，但是他也有缺點，密鑰需要在通訊的兩端共享，讓彼此知道密鑰是什麼對方才能正确解密，如果所有用戶端都共享同一個密鑰，那麼這個密鑰就像萬能鑰匙一樣，可以憑借一個密鑰破解所有人的密文了，如果每個用戶端與服務端單獨維護一個密鑰，那麼服務端需要管理的密鑰将是成千上萬，這會給服務端帶來噩夢 非對稱密鑰（public-key cryptography），又稱為公開密鑰加密，服務端會生成一對密鑰，一個私鑰儲存在服務端，僅自己知道，另一個是公鑰，公鑰可以自由釋出供任何人使用。用戶端的明文通過公鑰加密後的密文需要用私鑰解密。非對稱密鑰在加密和解密的過程的使用的密鑰是不同的密鑰，加密和解密是不對稱的，是以稱之為非對稱加密。與對稱密鑰加密相比，非對稱加密無需在用戶端和服務端之間共享密鑰，隻要私鑰不發給任何使用者，即使公鑰在網上被截獲，也無法被解密，僅有被竊取的公鑰是沒有任何用處的。常見的非對稱加密有RSA，非對稱加解密的過程：
1.服務端生成配對的公鑰和私鑰
2.私鑰儲存在服務端，公鑰發送給用戶端
3.用戶端使用公鑰加密明文傳輸給服務端
4.服務端使用私鑰解密密文得到明文 資料在浏覽器和伺服器之間傳輸時，有可能在傳輸過程中被冒充的盜賊把内容替換了，那麼如何保證資料是真實伺服器發送的而不被調包呢，同時如何保證傳輸的資料沒有被人篡改呢，要解決這兩個問題就必須用到數字簽名，數字簽名就如同日常生活的中的簽名一樣，一旦在合同書上落下了你的大名，從法律意義上就确定是你本人簽的字兒，這是任何人都沒法仿造的，因為這是你專有的手迹，任何人是造不出來的。那麼在計算機中的數字簽名怎麼回事呢？數字簽名就是用于驗證傳輸的内容是不是真實伺服器發送的資料，發送的資料有沒有被篡改過，它就幹這兩件事，是非對稱加密的一種應用場景。不過他是反過來用私鑰來加密，通過與之配對的公鑰來解密。
第一步：服務端把封包經過Hash處理後生成摘要資訊Digest，摘要資訊使用私鑰private-key加密之後就生成簽名，伺服器把簽名連同封包一起發送給用戶端。
第二步：用戶端接收到資料後，把簽名提取出來用public-key解密，如果能正常的解密出來Digest2，那麼就能确認是對方發的。
第三步：用戶端把封包Text提取出來做同樣的Hash處理，得到的摘要資訊Digest1，再與之前解密出來的Digist2對比，如果兩者相等，就表示内容沒有被篡改，否則内容就是被人改過了。因為隻要文本内容哪怕有任何一點點改動都會Hash出一個完全不一樣的摘要資訊出來。 數字證書簡稱CA，它由權威機構給某網站頒發的一種認可憑證，這個憑證是被大家（浏覽器）所認可的，為什麼需要用數字證書呢，難道有了數字簽名還不夠安全嗎？有這樣一種情況，就是浏覽器無法确定所有的真實伺服器是不是真的是真實的，舉一個簡單的例子：A廠家給你們家安裝鎖，同時把鑰匙也交給你，隻要鑰匙能打開鎖，你就可以确定鑰匙和鎖是配對的，如果有人把鑰匙換了或者把鎖換了，你是打不開門的，你就知道肯定被竊取了，但是如果有人把鎖和鑰匙替換成另一套表面看起來差不多的，但品質差很多的，雖然鑰匙和鎖配套，但是你卻不能确定這是否真的是A廠家給你的，那麼這時候，你可以找質檢部門來檢驗一下，這套鎖是不是真的來自于A廠家，質檢部門是權威機構，他說的話是可以被公衆認可的（呵呵）。
同樣的， 因為如果有人（張三）用自己的公鑰把真實伺服器發送給浏覽器的公鑰替換了，于是張三用自己的私鑰執行相同的步驟對文本Hash、數字簽名，最後得到的結果都沒什麼問題，但事實上浏覽器看到的東西卻不是真實伺服器給的，而是被張三從裡到外（公鑰到私鑰）換了一通。那麼如何保證你現在使用的公鑰就是真實伺服器發給你的呢？我們就用數字證書來解決這個問題。數字證書一般由數字證書認證機構（Certificate Authority）頒發，證書裡面包含了真實伺服器的公鑰和網站的一些其他資訊，數字證書機構用自己的私鑰加密後發給浏覽器，浏覽器使用數字證書機構的公鑰解密後得到真實伺服器的公鑰。這個過程是建立在被大家所認可的證書機構之上得到的公鑰，是以這是一種安全的方式。