CA证书

Author: gitking

Demo/dos.txt

@@ -0,0 +1,8 @@
+/Father.class
+/SubClass.class
+/Test.class
+/com/
+/conf/
+/dom4j.xml
+/dom4j2.xml
+/xPath.xml

bin/.gitignore

@@ -0,0 +1 @@
+你好你好你好你好你好

file.txt

@@ -12,6 +12,7 @@
  * 如果我们把默认的配置放到jar包中，再从外部文件系统读取一个可选的配置文件，就可以做到既有默认的配置文件，又可以让用户自己修改配置：
  * 这样读取配置文件，应用程序启动就更加灵活。
  * Class对象的getResourceAsStream()可以从classpath中读取指定资源；
+ * https://www.liaoxuefeng.com/wiki/1252599548343744/1298366384308257
  * @author dell
  */
 public class ClassPathInput {

src/com/yale/test/io/file/ClassPathInput.java

@@ -16,6 +16,7 @@
 import javax.crypto.spec.SecretKeySpec;
 
 /*
+ * 对称加密算法
  * 对称加密算法就是传统的用一个密码进行加密和解密。例如，我们常用的WinZIP和WinRAR对压缩包的加密和解密，就是使用对称加密算法：
  * 从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文：
  * secret = encrypt(key, message);
@@ -35,6 +36,11 @@ public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorit
 			/*
 			 * 使用AES加密:AES算法是目前应用最广泛的加密算法。我们先用ECB模式加密并解密：
 			 * AES加密有多种工作模式:ECB模式,CBC模式,PCBC模式,CTR模式
+			 * 注意AES加密相当于是WinZIP和WinRAR对你要打包的文件进行加密,跟你在用WinZIP和WinRAR时输入的密码没有任何关系.
+			 * 下面的message = "Hello,world!"这个就相当于文件,AES要对这些文件进行加密
+			 * "1234567890abcdef".getBytes("UTF-8") 注意这行代码,这行代码是AES自己指定的16bytes的密钥,不是你输入的那个密码
+			 * 你在用WinZIP和WinRAR时输入的密码在AES加密这里都没有用到,懂了吧,你这个密码只是为了打开压缩包时验证一下是你本人打开的
+			 * 跟加密文件没有任何关系
 			 */
 			String message = "Hello,world!";
 			System.out.println("Message明文:" + message);

src/com/yale/test/ps/AESDemo.java

@@ -0,0 +1,122 @@
+package com.yale.test.ps;
+
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.Security;
+import java.security.spec.InvalidKeySpecException;
+import java.util.Base64;
+
+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.PBEKeySpec;
+import javax.crypto.spec.PBEParameterSpec;
+
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+
+/*
+ * 口令加密算法
+ * 上一节我们讲的AES加密，细心的童鞋可能会发现，密钥长度是固定的128/192/256位，而不是我们用WinZip/WinRAR那样，随便输入几位都可以。
+ * 这是因为对称加密算法决定了口令必须是固定长度，然后对明文进行分块加密。又因为安全需求，口令长度往往都是128位以上，即至少16个字符。
+ * 但是我们平时使用的加密软件，输入6位、8位都可以，难道加密方式不一样？
+ * 实际上用户输入的口令并不能直接作为AES的密钥进行加密（除非长度恰好是128/192/256位），并且用户输入的口令一般都有规律，安全性远远不如安全随机数产生的随机口令。
+ * 因此，用户输入的口令，通常还需要使用PBE算法，采用随机数杂凑计算出真正的密钥，再进行加密。
+ * PBE就是Password Based Encryption的缩写，它的作用如下：
+ * key = generate(userPassword, secureRandomPassword);
+ * PBE的作用就是把用户输入的口令和一个安全随机的口令采用杂凑后计算出真正的密钥。以AES密钥为例，我们让用户输入一个口令，然后生成一个随机数，通过PBE算法计算出真正的AES口令，再进行加密，代码如下：
+ * 理解原理，PBE假定用户的口令很简单不安全，所以需要一个高强度密码和用户口令混在一起加密
+ */
+public class AesPbeDemo {
+	public static void main(String[] args) {
+		//PBE的作用就是把用户输入的口令和一个安全随机的口令采用杂凑后计算出真正的密钥。以AES密钥为例，我们让用户输入一个口令，然后生成一个随机数，通过PBE算法计算出真正的AES口令，再进行加密，代码如下：
+		Security.addProvider(new BouncyCastleProvider());//把BouncyCastle作为Provider添加到java.security
+		String message = "Hello,world!";//明文相当于文件
+		String password = "hello12345";//加密口令,相当于你输入的密码
+		
+		try {
+			byte[] salt = SecureRandom.getInstanceStrong().generateSeed(16);//16byte随机Salt,密钥
+			System.out.printf("salt:%032x\n", new BigInteger(1, salt));
+			
+			byte[] data = message.getBytes("UTF-8");
+			byte[] encrypted = encrypt(password, salt, data);//加密
+			System.out.println("加密encrypted:" + Base64.getEncoder().encodeToString(encrypted));
+			
+			//解密
+			byte[] decrypted = decrypt(password, salt, encrypted);
+			System.out.println("解密decrypted:" + new String(decrypted, "UTF-8"));
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		} catch (InvalidKeyException e) {
+			e.printStackTrace();
+		} catch (InvalidKeySpecException e) {
+			e.printStackTrace();
+		} catch (NoSuchPaddingException e) {
+			e.printStackTrace();
+		} catch (InvalidAlgorithmParameterException e) {
+			e.printStackTrace();
+		} catch (IllegalBlockSizeException e) {
+			e.printStackTrace();
+		} catch (BadPaddingException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	/*
+	 * PBE加密
+	 * 使用PBE时，我们还需要引入BouncyCastle，并指定算法是PBEwithSHA1and128bitAES-CBC-BC。观察代码，实际上真正的AES密钥是调用Cipher的init()方法时同时传入SecretKey和PBEParameterSpec实现的。
+	 * 在创建PBEParameterSpec的时候，我们还指定了循环次数1000，循环次数越多，暴力破解需要的计算量就越大。
+	 * 如果我们把salt和循环次数固定，就得到了一个通用的“口令”加密软件。如果我们把随机生成的salt存储在U盘，就得到了一个“口令”加USB Key的加密软件，它的好处在于，即使用户使用了一个非常弱的口令，
+	 * 没有USB Key仍然无法解密，因为USB Key存储的随机数密钥安全性非常高。 
+	 * 这个其实主要用于加密文件和解密文件,比如你把一个文件加密了,但是这个加密的文件被黑客拿走了,并且黑客知道你的密码(口令),但是黑客不知道你的salt,黑客仍然打不开这个加密的文件
+	 * 我自己用的时候把salt拿出来就行了。
+	 * 小结
+	 * PBE算法通过用户口令和安全的随机salt计算出Key，然后再进行加密；
+	 * Key通过口令和安全的随机salt计算得出，大大提高了安全性；
+	 * PBE算法内部使用的仍然是标准对称加密算法（例如AES）。
+	 * 理解原理，PBE假定用户的口令很简单不安全，所以需要一个高强度密码和用户口令混在一起加密
+	 */
+	public static byte[] encrypt(String password, byte[] salt, byte[] input) 
+	throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException{
+		PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray());//口令
+		SecretKeyFactory skeyFactory = SecretKeyFactory.getInstance("PBEwithSHA1and128bitAES-CBC-BC");
+		SecretKey skey = skeyFactory.generateSecret(keySpec);
+		PBEParameterSpec pbeps = new PBEParameterSpec(salt, 1000);
+		Cipher cipher = Cipher.getInstance("PBEwithSHA1and128bitAES-CBC-BC");
+		cipher.init(Cipher.ENCRYPT_MODE, skey, pbeps);
+		return cipher.doFinal(input);//加密明文
+	}
+	
+	/**
+	 * 解密
+	 * @param password 口令
+	 * @param salt 
+	 * @param input 加密后的明文
+	 * @return
+	 * @throws NoSuchAlgorithmException
+	 * @throws InvalidKeySpecException
+	 * @throws NoSuchPaddingException
+	 * @throws InvalidKeyException
+	 * @throws InvalidAlgorithmParameterException
+	 * @throws IllegalBlockSizeException
+	 * @throws BadPaddingException
+	 */
+	public static byte[] decrypt(String password, byte[] salt, byte[] input)
+	throws NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException {
+		PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray());
+		SecretKeyFactory skeyFactory = SecretKeyFactory.getInstance("PBEwithSHA1and128bitAES-CBC-BC");
+		SecretKey skey = skeyFactory.generateSecret(keySpec);
+		PBEParameterSpec pbeps = new PBEParameterSpec(salt, 1000);
+		Cipher cipher = Cipher.getInstance("PBEwithSHA1and128bitAES-CBC-BC");
+		cipher.init(Cipher.DECRYPT_MODE, skey, pbeps);
+		return cipher.doFinal(input);//解密
+	}
+}

src/com/yale/test/ps/AesPbeDemo.java

@@ -0,0 +1,134 @@
+package com.yale.test.ps;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.math.BigInteger;
+import java.security.InvalidKeyException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.Signature;
+import java.security.SignatureException;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+
+
+/*
+ * 数字证书
+ * 我们知道，摘要算法用来确保数据没有被篡改，非对称加密算法可以对数据进行加解密，签名算法可以确保数据完整性和抗否认性，把这些算法集合到一起，并搞一套完善的标准，这就是数字证书。
+ * 因此，数字证书就是集合了多种密码学算法，用于实现数据加解密、身份认证、签名等多种功能的一种安全标准。
+ * 数字证书可以防止中间人攻击，因为它采用链式签名认证，即通过根证书（Root CA）去签名下一级证书，这样层层签名，直到最终的用户证书。而Root CA证书内置于操作系统中，所以，任何经过CA认证的数字证书都可以对其本身进行校验，确保证书本身不是伪造的。
+ * 我们在上网时常用的HTTPS协议就是数字证书的应用。浏览器会自动验证证书的有效性：
+ * 要使用数字证书，首先需要创建证书。正常情况下，一个合法的数字证书需要经过CA签名，这需要认证域名并支付一定的费用。开发的时候，我们可以使用自签名的证书，
+ * 这种证书可以正常开发调试，但不能对外作为服务使用，因为其他客户端并不认可未经CA签名的证书。
+ * 在Java程序中，数字证书存储在一种Java专用的key store文件中，JDK提供了一系列命令来创建和管理key store。我们用下面的命令创建一个key store，并设定口令123456：
+ * keytool -storepass 123456 -genkeypair -keyalg RSA -keysize 1024 -sigalg SHA1withRSA -validity 3650 -alias mycert -keystore my.keystore -dname "CN=www.sample.com, OU=sample, O=sample, L=BJ, ST=BJ, C=CN"
+ * 几个主要的参数是：
+    keyalg：指定RSA加密算法；
+    sigalg：指定SHA1withRSA签名算法；
+    validity：指定证书有效期3650天；
+    alias：指定证书在程序中引用的名称；
+    dname：最重要的CN=www.sample.com指定了Common Name，如果证书用在HTTPS中，这个名称必须与域名完全一致。
+ * 执行上述命令，JDK会在当前目录创建一个my.keystore文件，并存储创建成功的一个私钥和一个证书，它的别名是mycert。
+ * 有了key store存储的证书，我们就可以通过数字证书进行加解密和签名：
+ * 在上述代码中，我们从key store直接读取了私钥-公钥对，私钥以PrivateKey实例表示，公钥以X509Certificate表示，实际上数字证书只包含公钥，因此，读取证书并不需要口令，只有读取私钥才需要。如果部署到Web服务器上，例如Nginx，需要把私钥导出为Private Key格式，把证书导出为X509Certificate格式。
+ * 以HTTPS协议为例，浏览器和服务器建立安全连接的步骤如下：
+ * 	1.浏览器向服务器发起请求，服务器向浏览器发送自己的数字证书；
+ *  2.浏览器用操作系统内置的Root CA来验证服务器的证书是否有效，如果有效，就使用该证书加密一个随机的AES口令并发送给服务器；
+ *  3.服务器用自己的私钥解密获得AES口令，并在后续通讯中使用AES加密。
+ * 上述流程只是一种最常见的单向验证。如果服务器还要验证客户端，那么客户端也需要把自己的证书发送给服务器验证，这种场景常见于网银等。
+ * 注意：数字证书存储的是公钥，以及相关的证书链和算法信息。私钥必须严格保密，如果数字证书对应的私钥泄漏，就会造成严重的安全威胁。如果CA证书的私钥泄漏，那么该CA证书签发的所有证书将不可信。
+ * 数字证书服务商DigiNotar(https://en.wikipedia.org/wiki/DigiNotar)就发生过私钥泄漏导致公司破产的事故。
+ */
+public class CASignDemo {
+	public static void main(String[] args) 
+	throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException, UnrecoverableKeyException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, SignatureException {
+		byte[] message = "Hello, use X:509 cert!".getBytes("UTF-8");
+		//读取KeyStore
+		KeyStore ks = loadKeyStore("/my.keystore", "123456");
+		
+		//读取私钥:
+		PrivateKey privateKey = (PrivateKey)ks.getKey("mycert", "123456".toCharArray());
+		
+		//读取证书:
+		X509Certificate certificate = (X509Certificate)ks.getCertificate("mycert");
+		
+		//加密:
+		byte[] encrypted = encrypt(certificate, message);
+		System.out.println(String.format("加密后的字符串,encrypted:%x", new BigInteger(1, encrypted)));
+		
+		//解密
+		byte[] decrypted = decrypt(privateKey, encrypted);
+		System.out.println("解密,decrypted:" + new String(decrypted, "UTF-8"));
+		
+		//签名:
+		byte[] sign = sign(privateKey, certificate, message);
+		System.out.println(String.format("signature:%x", new BigInteger(1, sign)));
+		
+		//验证签名
+		boolean verified = verify(certificate, message, sign);
+		System.out.println("验证签名是否通过:" + verified);
+	}
+	
+	static KeyStore loadKeyStore(String keyStoreFile, String password)
+	throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException {
+		try(InputStream input = CASignDemo.class.getResourceAsStream(keyStoreFile)) {
+			if (input == null) {
+				throw new RuntimeException("file not found in classpath:" + keyStoreFile);
+			}
+			KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+			ks.load(input, password.toCharArray());
+			return ks;
+		} catch (KeyStoreException e) {
+			e.printStackTrace();
+			throw e;
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+			throw e;
+		} catch (CertificateException e) {
+			e.printStackTrace();
+			throw e;
+		} catch (IOException e) {
+			e.printStackTrace();
+			throw e;
+		}
+	}
+	
+	static byte[] encrypt(X509Certificate certificate, byte[] message)
+	throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
+		Cipher cipher = Cipher.getInstance(certificate.getPublicKey().getAlgorithm());
+		cipher.init(Cipher.ENCRYPT_MODE, certificate.getPublicKey());
+		return cipher.doFinal(message);
+	}
+	
+	static byte[] decrypt(PrivateKey privateKey, byte[] data)
+	throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
+		Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
+		cipher.init(Cipher.DECRYPT_MODE, privateKey);
+		return cipher.doFinal(data);
+	}
+	
+	static byte[] sign(PrivateKey privateKey, X509Certificate certificate, byte[] message) 
+	throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
+		Signature signature = Signature.getInstance(certificate.getSigAlgName());
+		signature.initSign(privateKey);
+		signature.update(message);
+		return signature.sign();
+	}
+	
+	static boolean verify(X509Certificate certificate, byte[] message, byte[] sig)
+	throws NoSuchAlgorithmException, InvalidKeyException, SignatureException {
+		Signature signature = Signature.getInstance(certificate.getSigAlgName());
+		signature.initVerify(certificate);
+		signature.update(message);
+		return signature.verify(sig);
+	}
+}