凱撒密碼
第一個案例，對字元進行簡單的加密。
- 對字元數組中所有的字元做+1處理（後面可以轉換成+num這個數由通訊雙方來協定）
代碼
/**
*對字元簡單的加密
*/
public class SimpleEncryptionDemo01 {
public static void main(String[] args) {
// 确定加密的内容
String content = "i love you tonight 404 see you z";
//加密
String encryptData = encrypt(content);
System.out.println("加密後：" + encryptData);
//解密
String decryptData = decrypt(encryptData);
System.out.println("解密後：" + decryptData);
}
/**
* 加密方法
*
* @param content
* @return
*/
public static String encrypt(String content) {
// 将内容轉換成字元數組
char[] charArray = content.toCharArray();
// 周遊出所有字元
for (int i = ; i < charArray.length; i++) {
// 對所有字元進行 + 1操作
charArray[i] = (char) (charArray[i] + );
}
return new String(charArray);
}
/**
* 解密方法
*
* @param encryptData
* @return
*/
public static String decrypt(String encryptData) {
// 将内容轉換成字元數組
char[] charArray = encryptData.toCharArray();
System.out.println(new String(charArray));
// 解密
for (int i = ; i < charArray.length; i++) {
charArray[i] = (char) (charArray[i] - );
}
return new String(charArray);
}
}
第二個案例，對位元組進行簡單的加密。
位元組和字元的差別？
* UTF-8編碼下，一個英文或數字字元就是一個位元組
* UTF-8編碼下，一個漢字代表三個位元組。
* 為什麼new String(bytes)的時候回發生亂碼，就是因為加密後得到的位元組找不到對應的字元。
* Base64的原理
代碼
/**
*對位元組進行加密
*/
public class SimpleEncryptionDemo2 {
public static void main(String[] args) {
// 測試位元組字元
String content = "中文";
int key = ;
String encryptData = encrypt(content,key);
System.out.println("＋密後:" + encryptData);
String decryptData = decrypt(encryptData,key);
System.out.println("解密後:" + decryptData);
}
/**
* 加密
*
* @param content
* @return
*/
public static String encrypt(String content,int key) {
// 第一步，轉換成位元組數組
byte[] bytes = content.getBytes();
System.out.println("列印未加密的位元組數組：");
Util.printBytes(bytes);
System.out.println("_________________________________________");
// 第二步，周遊出所有位元組，并做+1處理
for (int i = ; i < bytes.length; i++) {
bytes[i] = (byte) (bytes[i] + key);
}
System.out.println("列印加密的位元組數組：");
Util.printBytes(bytes);
System.out.println("_________________________________________");
// return new String(bytes);
return Base64.getEncoder().encodeToString(bytes);
}
/**
* 解密
* @param encryptData
* @return
*/
public static String decrypt(String encryptData,int key) {
// 第一步，轉換成位元組數組,加密時使用Base64編碼，那解密時也要使用Base64解碼
byte[] bytes = Base64.getDecoder().decode(encryptData);
// byte[] bytes = encryptData.getBytes();
System.out.println("列印經過兩次轉換後的位元組數組：");
Util.printBytes(bytes);
System.out.println("_________________________________________");
// 解密
for (int i = ; i < bytes.length; i++) {
bytes[i] = (byte) (bytes[i] - key);
}
System.out.println("列印解密後的位元組數組：");
Util.printBytes(bytes);
System.out.println("_________________________________________");
return new String(bytes);
}
}
對稱加密與非對稱加密
- 對稱加密與非對稱加密的差別
- 對稱加密。同一把鑰匙進行加密和解密
- 非對稱加密，公鑰加密，私鑰解密。
對稱加密的案例
常見算法：AES、DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK
AES:進階加密标準（Advanced Encryption Standard)
DES:資料加密标準(Data Encryption Standard)
對稱加密第一個案例
public class SymmetricalEncryptionDemo01 {
public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException {
// 聲明要加密的内容
String content = "今晚404，不見不散";
//生成key
SecretKey key = createKey();
//加密
String encryptData = encrypt(content, key);
System.out.println(encryptData);
//解密
String decryptData = decrypt(encryptData, key);
System.out.println(decryptData);
}
/**
* 生成key
* @return
* @throws NoSuchAlgorithmException
*/
public static SecretKey createKey() throws NoSuchAlgorithmException {
// 生成key
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
SecretKey secretKey = keyGenerator.generateKey();
return secretKey;
}
/**
* 加密方法
*
* @param content
* @return
* @throws InvalidKeyException
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
*/
public static String encrypt(String content, SecretKey key) throws InvalidKeyException, NoSuchAlgorithmException,
NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
// 擷取cipher單例對象
Cipher cipher = Cipher.getInstance("AES");
// 初始化cipher,設定為加密模式
cipher.init(Cipher.ENCRYPT_MODE, key);
// 開始加密
byte[] encryptBytes = cipher.doFinal(content.getBytes());
return Base64.getEncoder().encodeToString(encryptBytes);
}
/**
* @param encryptData
* @return
*/
public static String decrypt(String encryptData, SecretKey key) throws InvalidKeyException,
NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
byte[] encryptBytes = Base64.getDecoder().decode(encryptData);
// 擷取cipher單例對象
Cipher cipher = Cipher.getInstance("AES");
// 解密
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
}
對稱加密的第二個案例
将生成的key儲存到本地，然後解密時和下一次加密時就隻需要到本地讀取即可。。
/**
*儲存key到本地
*/
public class SymmetricalEncryptionDemo02 {
public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException {
// 聲明要加密的内容
String content = "今晚404，不見不散";
//第一次生成key,并序列化到本地
// SecretKey key = createKey();
// SerializableUtil.saveObject2File("aric.key", key);
//從檔案中讀取key
SecretKey key = (SecretKey) SerializableUtil.readObjectFromFile("aric.key");
System.out.println(key);
//加密
String encryptData = encrypt(content, key);
System.out.println(encryptData);
//解密
String decryptData = decrypt(encryptData, key);
System.out.println(decryptData);
}
/**
* 生成key
* @return
* @throws NoSuchAlgorithmException
*/
public static SecretKey createKey() throws NoSuchAlgorithmException {
// 生成key
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
SecretKey secretKey = keyGenerator.generateKey();
return secretKey;
}
/**
* 加密方法
*
* @param content
* @return
* @throws InvalidKeyException
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
*/
public static String encrypt(String content, SecretKey key) throws InvalidKeyException, NoSuchAlgorithmException,
NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
// 擷取cipher單例對象
Cipher cipher = Cipher.getInstance("AES");
// 初始化cipher,設定為加密模式
cipher.init(Cipher.ENCRYPT_MODE, key);
// 開始加密
byte[] encryptBytes = cipher.doFinal(content.getBytes());
return Base64.getEncoder().encodeToString(encryptBytes);
}
/**
* @param encryptData
* @return
*/
public static String decrypt(String encryptData, SecretKey key) throws InvalidKeyException,
NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
byte[] encryptBytes = Base64.getDecoder().decode(encryptData);
// 擷取cipher單例對象
Cipher cipher = Cipher.getInstance("AES");
// 解密
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
}
第三個案例——自定義秘鑰，代碼
/**
* 生成key
* @return
* @throws NoSuchAlgorithmException
*/
public static SecretKey createKey(String keyword) throws NoSuchAlgorithmException {
// 生成key
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(new SecureRandom(keyword.getBytes()));
SecretKey secretKey = keyGenerator.generateKey();
return secretKey;
}
優點
- 使用簡單，友善
- 效率高，速度快
缺點
- 密鑰傳輸過程中容易被截獲
應用場景
- 登入，post請求{username=lisi,pw=加密}
非對稱加密的案例
常見算法：RSA、Elgamal、背包算法、Rabin、D-H、ECC（橢圓曲線加密算法）等
應用場景：銀行和電商網站，他就采用非對稱加密，将公鑰給所有人，你們就用這個公鑰加密，私鑰我自己留着，誰也不知道，是以除了我，誰也解密不了。
第一個案例
（資料量不大的情況下可用，加密資料小于117個位元組，解密資料小于128個位元組）
public class AysmmetricEncryptionDemo {
public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
IllegalBlockSizeException, BadPaddingException {
String content = "今晚小樹林，等你哦";
//生成密鑰對
KeyPair keyPair = createKeyypair();
//擷取公鑰私鑰
PublicKey publicKey = keyPair.getPublic();
PrivateKey privateKey = keyPair.getPrivate();
//加密
String encryptData = encrypt(content, publicKey);
System.out.println("加密後：" + encryptData);
//解密
String decryptData = decrypt(encryptData, privateKey);
System.out.println("解密後：" + decryptData);
}
/**
* 生成秘鑰對
* @return
* @throws NoSuchAlgorithmException
*/
public static KeyPair createKeyypair() throws NoSuchAlgorithmException{
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
KeyPair keyPair = keyPairGenerator.generateKeyPair();
return keyPair;
}
/**
* 加密
*
* @param content
* @return
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws InvalidKeyException
*/
public static String encrypt(String content, PublicKey publicKey) throws NoSuchAlgorithmException,
NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {
// 擷取cipher對象
Cipher cipher = Cipher.getInstance("RSA");
// 初始化cipher，指定模式為加密，傳入公鑰
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptBytes = cipher.doFinal(content.getBytes());
return Base64.getEncoder().encodeToString(encryptBytes);
}
/**
* 解密方法
*
* @param encryptData
* @param privateKey
* @return
* @throws NoSuchPaddingException
* @throws NoSuchAlgorithmException
* @throws InvalidKeyException
* @throws BadPaddingException
* @throws IllegalBlockSizeException
* @throws Exception
*/
public static String decrypt(String encryptData, PrivateKey privateKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
byte[] encryptBytes = Base64.getDecoder().decode(encryptData);
// 擷取cipher對象
Cipher cipher = Cipher.getInstance("RSA");
// 小芝解密
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptBytes = cipher.doFinal(encryptBytes);
return new String(decryptBytes);
}
}
如果資料量大的話，則要對要加密、解密的資料進行分塊處理
/**
* 處理大量資料時，分塊加密/解密
* @param content
* @param cipher
* @param max
* @return
* @throws IllegalBlockSizeException
* @throws BadPaddingException
* @throws IOException
*/
private static byte[] doFinalWithBlock(byte[] bytes, Cipher cipher,int max)
throws IllegalBlockSizeException, BadPaddingException, IOException {
int len = bytes.length;//3000
//加密資料長度不能超過117個byte
int inputOffset = ;//2700
ByteArrayOutputStream baos = new ByteArrayOutputStream();
while (len > inputOffset) {
//特殊情況，最後一次剩下的資料不足117
if ((len - inputOffset) >= max) {
byte[] encryptBytes = cipher.doFinal(bytes, inputOffset, max);
baos.write(encryptBytes);
inputOffset += max;
}else {
byte[] encryptBytes = cipher.doFinal(bytes, inputOffset, len - inputOffset);
baos.write(encryptBytes);
inputOffset = len;
}
}
byte[] byteArray = baos.toByteArray();
return byteArray;
}
消息摘要
消息摘要是一個不可逆的過程。常用來防篡改。
常見算法：MD5、SHA、CRC等
byte數組和16進制字元串的互轉
/**
* byte數組轉16進制字元串
* @param bytes
* @return
*/
public static String bytes2Hex(byte[] bytes){
StringBuffer sBuffer = new StringBuffer();
for (int i = ; i < bytes.length; i++) {
//取高位
int high = (bytes[i] & ) >> ;
//取低位
int low = bytes[i] & ;
sBuffer.append(HEXSTR[high]).append(HEXSTR[low]);
}
return sBuffer.toString();
}
/**
* 16進制字元串轉位元組數組
* @param hex
* @return
*/
public static byte[] hex2Bytes(String hex){
int len = hex.length()/;
//聲明一個位元組數組用于接收轉換後的位元組
byte[] bytes = new byte[len];
for (int i = ; i < len; i++) {
//首先取高位,取偶數位
String highStr = hex.substring( * i, * i + );
String lowStr = hex.substring( * i + , * i + );
int high = Integer.parseInt(highStr, ) << ;
int low = Integer.parseInt(lowStr, );
bytes[i] = (byte) (high + low);
}
return bytes;
}
數字簽名
- 首先防止偷看消息，消息内容是要公鑰加密——為了防止别人截獲消息之後，閱讀消息。
- 防止别人改消息，1.對消息進行MD5加密——MD5值，2.對MD5用張三的私鑰進行加密！3.将加密後的MD5值和消息一同發給伺服器。
- 伺服器用張三的公鑰解密MD5值，然後将消息用MD5加密——得到MD5值，對比兩個MD5值，如果相等，消息沒被篡改。
Signature
public class DigitalSignatureDemo {
public static void main(String[] args) throws Exception {
String content = "今晚六點半，不見不散！！！";
byte[] bytes = content.getBytes();
//擷取數字簽名的單例對象
Signature signature = Signature.getInstance("MD5withRSA");
//從檔案中讀取私鑰
PrivateKey privateKey = (PrivateKey) SerializableUtil.readObjectFromFile("aric.privateKey");
//私鑰跟公鑰不是一對，那麼認證失敗！
// KeyPairGenerator pairGenerator = KeyPairGenerator.getInstance("RSA");
/ KeyPair keyPair = pairGenerator.generateKeyPair();
// PrivateKey privateKey = keyPair.getPrivate();
//初始化簽名
signature.initSign(privateKey);
//加載内容
signature.update(bytes);
//進行簽名
byte[] signBytes = signature.sign();//得到簽名後的byte數組，就相當于私鑰加密後的MD5值
//擷取公鑰
PublicKey publicKey = (PublicKey) SerializableUtil.readObjectFromFile("aric.publicKey");
//認證流程
//初始化認證
signature.initVerify(publicKey);
// String content2 = "今晚八點，606嘿嘿嘿！";
//加載内容
signature.update(bytes);
//認證
boolean verify = signature.verify(signBytes);//認證加密後的MD5值
System.out.println(verify);
}
}
keytool的使用。
- 生成keyPair keytool -genkeypair
- 修改别名 keytool -changealias -alias mykey -destalias aric
- 導出證書 keytool -exportcert
- 導入證書 keytool -importcert
擷取檔案中的證書
// 獲驗證書工廠的執行個體
CertificateFactory cf = CertificateFactory.getInstance("X.509");
FileInputStream inStream = new FileInputStream(new File("aric.cer"));
X509Certificate certificate = (X509Certificate) cf.generateCertificate(inStream);
SSl
單向/雙向認證的原理
為了便于更好的認識和了解 SSL 協定，這裡着重介紹 SSL 協定的握手協定。SSL 協定既用到了公鑰加密技術又用到了對稱加密技術，對稱加密技術雖然比公鑰加密技術的速度快，可是公鑰加密技術提供了更好的身份認證技術。SSL 的握手協定非常有效的讓客戶和伺服器之間完成互相之間的身份認證，其主要過程如下：
- ① 用戶端的浏覽器向伺服器傳送用戶端 SSL 協定的版本号，加密算法的種類，産生的随機數，以及其他伺服器和用戶端之間通訊所需要的各種資訊。
- ② 伺服器向用戶端傳送 SSL 協定的版本号，加密算法的種類，随機數以及其他相關資訊，同時伺服器還将向用戶端傳送自己的證書。
- ③ 客戶利用伺服器傳過來的資訊驗證伺服器的合法性，伺服器的合法性包括：證書是否過期，發行伺服器證書的 CA 是否可靠，發行者證書的公鑰能否正确解開伺服器證書的“發行者的數字簽名”，伺服器證書上的域名是否和伺服器的實際域名相比對。如果合法性驗證沒有通過， 通訊将斷開；如果合法性驗證通過，将繼續進行第四步。
- ④ 使用者端随機産生一個用于後面通訊的“對稱密碼”，然後用伺服器的公鑰（伺服器的公鑰從步驟②中的伺服器的證書中獲得）對其加密，然後将加密後的“預主密碼”傳給伺服器。
- ⑤ 如果伺服器要求客戶的身份認證（在握手過程中為可選），使用者可以建立一個随機數然後對其進行資料簽名，将這個含有簽名的随機數和客戶自己的證書以及加密過的“預主密碼”一起傳給伺服器。（數字簽名）
- ⑥ 如果伺服器要求客戶的身份認證，伺服器必須檢驗客戶證書和簽名随機數的合法性，具體的合法性驗證過程包括：客戶的證書使用日期是否有效，為客戶提供證書的 CA 是否可靠，發行 CA 的公鑰能否正确解開客戶證書的發行 CA 的數字簽名，檢查客戶的證書是否在證書廢止清單（CRL）中。檢驗如果沒有通過，通訊立刻中斷；如果驗證通過，伺服器将用自己的私鑰解開加密的“預主密 碼”，然後執行一系列步驟來産生主通訊密碼（用戶端也将通過同樣的方法産生相同的主通訊密碼）。
- ⑦ 伺服器和用戶端用相同的主密碼即“通話密碼”，一個對稱密鑰用于 SSL 協定的安全資料通訊的加解密通訊。同時在 SSL 通訊過程中還要完成資料通訊的完整性，防止資料通訊中的任何變化。
- ⑧ 用戶端向伺服器端發出資訊，指明後面的資料通訊将使用的步驟⑦中的主密碼為對稱密鑰，同時通知伺服器用戶端的握手過程結束。
- ⑨ 伺服器向用戶端發出資訊，指明後面的資料通訊将使用的步驟⑦中的主密碼為對稱密鑰，同時通知用戶端伺服器端的握手過程結束。
- ⑩ SSL 的握手部分結束，SSL 安全通道的資料通訊開始，客戶和伺服器開始使用相同的對稱密鑰進行資料通訊，同時進行通訊完整性的檢驗。
雙向認證 SSL 協定的具體過程
① 浏覽器發送一個連接配接請求給安全伺服器。
② 伺服器将自己的證書，以及同證書相關的資訊發送給客戶浏覽器。
③ 客戶浏覽器檢查伺服器送過來的證書是否是由自己信賴的 CA 中心所簽發的。如果是，就繼續執行協定；如果不是，客戶浏覽器就給客戶一個警告消息：警告客戶這個證書不是可以信賴的，詢問客戶是否需要繼續。
④ 接着客戶浏覽器比較證書裡的消息，例如域名和公鑰，與伺服器剛剛發送的相關消息是否一緻，如果是一緻的，客戶浏覽器認可這個伺服器的合法身份。
⑤ 伺服器要求客戶發送客戶自己的證書。收到後，伺服器驗證客戶的證書，如果沒有通過驗證，拒絕連接配接；如果通過驗證，伺服器獲得使用者的公鑰。
⑥ 客戶浏覽器告訴伺服器自己所能夠支援的通訊對稱密碼方案。
⑦ 伺服器從客戶發送過來的密碼方案中，選擇一種加密程度最高的密碼方案，用客戶的公鑰加過密後通知浏覽器。
⑧ 浏覽器針對這個密碼方案，選擇一個通話密鑰，接着用伺服器的公鑰加過密後發送給伺服器。
⑨ 伺服器接收到浏覽器送過來的消息，用自己的私鑰解密，獲得通話密鑰。
⑩ 伺服器、浏覽器接下來的通訊都是用對稱密碼方案，對稱密鑰是加過密的。
代碼通路
public class HttpsDemo {
public static void main(String[] args) throws IOException, NoSuchAlgorithmException, KeyManagementException, KeyStoreException, CertificateException {
//第一種方式，我所有的證書都不檢查
SSLContext sslContext = SSLContext.getInstance("TLS");//TLS 是transport Layer safe
//擷取信任管理者工廠
TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
//擷取keyStore
KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
ks.load(null);
//從檔案中讀驗證書
CertificateFactory cf = CertificateFactory.getInstance("X.509");
FileInputStream inStream = new FileInputStream(new File("srca.cer"));
X509Certificate cert = (X509Certificate) cf.generateCertificate(inStream);
//給keyStore設定證書
ks.setCertificateEntry("12306", cert);
trustManagerFactory.init(ks);
TrustManager[] tm = trustManagerFactory.getTrustManagers();
sslContext.init(null, tm, null);
SSLSocketFactory socketFactory = sslContext.getSocketFactory();
HttpsURLConnection.setDefaultSSLSocketFactory(socketFactory);
// TODO Auto-generated method stub
URL url = new URL("https://kyfw.12306.cn/otn/");
//第二步，擷取coon
HttpsURLConnection coon = (HttpsURLConnection) url.openConnection();
InputStream inputStream = coon.getInputStream();
String response = Util.inputStream2String(inputStream);
System.out.println(response);
}
}
Tomcat配置https
1. 在server節點下配置如下的内容
<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
maxThreads="150" scheme="https" secure="true"
clientAuth="false" sslProtocol="TLS"
keystoreFile="證書的全路徑名稱" keystorePass="證書的密碼"/>
2. 建立證書
keytool -genkeypair -alias "aric" -keyalg "RSA" -keystore "haha.keystore"
3. 找到server .xml的這一句話
<Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" /> 把他注釋掉。
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)