导师邮件：上个程序基本搞差不多了，再继续做个练习：用java的 keytool 命令行产生一个rsa 2048 密钥的jks，然后通过程序使用jks里的密钥做签名。

分析:  功能实现分两步骤==>使用keytool命令行 生成 密钥对（可以接着产生证书、公钥、私钥），将密钥读入程序，并做签名

首先，使用keytool 产生 RSA 2048 密钥对,

然后，在程序中读入密钥文件，获取私钥，

最后，对数据进行签名，

附加，完成验签

——————————————————

1. 使用keytool 产生 RSA 2048 密钥对,

1.1 SHA256WithRSA生成密钥

keytool -genkey -v -alias rsa0 -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore rsa0.keystore

1.2 MD5WithRSA生成密钥

keytool -genkey -v -alias rsa1 -keyalg RSA -sigalg MD5withRSA -keysize 2048 -storetype PKCS12 -keystore rsa1.keystore

按指导完成证书条目的生成，生成keystore文件。

/* 之前的写法：

       keytool -genkey -v -alias rsa -keyalg RSA -keysize 2048 -keystore rsa.store -validity 10000

将 证书条码迁移 到 pkcs12 标准：

       keytool -importkeystore -srckeystore rsa.store -destkeystore rsa.store -deststoretype pkcs12

*/ 

2. 在程序中读入密钥文件，获取私钥，对数据进行签名，完成验签

package work_2;
 
import java.io.FileInputStream;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
 
import sun.misc.BASE64Encoder;
 
public class RSA_2 {
	// 待签名数据
	public static  String  src = "12345678";
	 public static void main(String[] args) throws Exception{ 
		    // 1. 指定 jks 文件的位置
	        String keyStoreType = "jks";
	        String keystoreFile = "E:\\1_Project\\1_Eclipse\\2_Test\\rsa.keystore";
	        
	        // 2. keystore 的密码 和 条目的密码
	        String password = "Infosec"; 			
	        String friendPassword = "Infosec";		
	       
	        // 3. 加载文件，通过密码验证
	        KeyStore keyStore = KeyStore.getInstance(keyStoreType);
	        keyStore.load(new FileInputStream(keystoreFile), password.toCharArray());
 
	        String alias = "rsa";//条目别名
	       
	        // 4. 导出 公钥 私钥
	        KeyPair keyPair = ExportCert.getKeyPair(keyStore, alias, friendPassword.toCharArray()); 
	        
	        byte[] privateKeyByte = keyPair.getPrivate().getEncoded(); // 私钥
	        byte[] publicKeyByte = keyPair.getPublic().getEncoded();  // 公钥
	        
	        String privateKeyString = new BASE64Encoder().encode(privateKeyByte);
	        String publicKeyString = new BASE64Encoder().encode(publicKeyByte);
	        
	      // System.out.println("privateKeyString的长度为："+privateKeyString.length());
	      // System.out.println(privateKeyString);
	        
	      // System.out.println("publicKeyString的长度为："+publicKeyString.length());
	      // System.out.println(publicKeyString);
	        
	        // 5. 完成签名处理
	        byte[] sign = sign(keyPair.getPrivate());
	        
	        // 6. 签名验签处理
	        verity(keyPair.getPublic(),sign);
	   }
	 
	 // 1. 得到密钥对 KeyPair
	 public static KeyPair getKeyPair(KeyStore keyStore, String alias, char[] password){
	     try{
	         Key key = keyStore.getKey(alias, password);
	         if (key instanceof PrivateKey){
	             Certificate certificate = keyStore.getCertificate(alias);
	             PublicKey publicKey = certificate.getPublicKey();
	             return new KeyPair(publicKey, (PrivateKey) key);
	         }
	     }catch (UnrecoverableKeyException | NoSuchAlgorithmException | KeyStoreException e){
	         e.printStackTrace();
	     }
	     return null;
	 } 
	// 2. 做签名，并返回
	 public static byte[] sign(PrivateKey privateKey) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException{
		 // 1. 选择 签名算法
		 Signature signature = Signature.getInstance("MD5WithRSA");
		 // 2. 初始化 私钥
		 signature.initSign(privateKey);
		 // 3. 更新 要签名的数据
		 signature.update(src.getBytes());
		 // 4. 签名，并发挥签名
		 byte[] signByte = signature.sign();
		 return signByte; 
	 }
	 
	 // 3. 验签
	 public static void verity(PublicKey publicKey,byte[] sign) throws NoSuchAlgorithmException, InvalidKeyException, SignatureException{
		 // 1. 选择 验签算法	 
		 Signature signature = Signature.getInstance("MD5WithRSA");
		 // 2. 初始化公钥
		 signature.initVerify(publicKey);
		 // 3. 更新 要验证的 数据
		 signature.update(src.getBytes());
		 // 4. 验证处理   （signature 中保存着 更新过的src,通过verify 处理原文得到，签名和之前的签名对比）
		 				//	（此处留有疑问，特别是对于update的具体实现细节）
		 boolean flag = signature.verify(sign);
		 // 5. 输出  验证结果
		 System.out.println("经过验证发现，签名是："+ flag);
	 }
}

输出结果：

完成基本功能实现，现在发给 导师。

记录一下:

CMD生成 密钥

1. keytool -genkeypair -alias "test1" -keyalg "RSA" -keystore "test.keystore"  

2.keytool -importkeystore -srckeystore test.keystore -destkeystore test.keystore -deststoretype pkcs12

3. keytool -genkey -v -alias rsa -keyalg RSA -keysize 2048 -keystore rsa.store -validity 10000

SHA256WithRSA生成密钥

4. keytool -genkey -v -alias rsa -keyalg RSA -keysize 2048 -storetype PKCS12 -keystore rsa.keystore  -dname "CN=www.infosec.com,OU=infosec,O=infosec,L=bj,ST=bj,C=cn" -storepass Infosec -keypass Infosec

使用 MD5WithRSA生成密钥

5. keytool -genkey -v -alias rsa2 -keyalg RSA -sigalg MD5withRSA -keysize 2048 -storetype PKCS12 -keystore rsa2.keystore -dname "CN=www.infosec.com,OU=infosec,O=infosec,L=bj,ST=bj,C=cn" -storepass Infosec -keypass Infosec

over…