数字签名之DASSignature

迈不过友情╰ 2022-07-14 14:51 75阅读 0赞

1、DSA 签名算法概念

** DSA 算法实现就是 RSA 数字签名算法实现的简装版，仅支持 SHA 系列算法。**

2、DSA 签名算法分类（JDK实现）

SHA1withDSA

3、DSASignature 算法的编程使用

3.1 签名

![20161213223907721][]

3.2 验证

![20161213223920897][]

4、DSASignature 算法的实现

import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.Signature;
    import java.security.interfaces.DSAPrivateKey;
    import java.security.interfaces.DSAPublicKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    public class DSASignatureUtil {
    
    	public static final String KEY_ALGORITHM = "DSA";
    	public static final int KEY_SIZE = 1024;
    	public static final String DSA_PUBLIC_KEY = "DSA_PUBLIC_KEY";
    	public static final String DSA_PRIVATE_KEY = "DSA_PRIVATE_KEY";
    	public static final String SIGNATURE_ALGORITHM = "SHA1withDSA";
    
    	/**
    	 * 生成 公私钥 密钥对
    	 * 
    	 * @return
    	 */
    	public static Map<String, Object> initKey() {
    		try {
    			KeyPairGenerator keyPairGenerator = KeyPairGenerator
    					.getInstance(KEY_ALGORITHM);
    			keyPairGenerator.initialize(KEY_SIZE);
    			KeyPair keyPair = keyPairGenerator.generateKeyPair();
    			DSAPublicKey publicKey = (DSAPublicKey) keyPair.getPublic();
    			DSAPrivateKey privateKey = (DSAPrivateKey) keyPair.getPrivate();
    			Map<String, Object> keyMap = new HashMap<String, Object>();
    			keyMap.put(DSA_PUBLIC_KEY, publicKey);
    			keyMap.put(DSA_PRIVATE_KEY, privateKey);
    			return keyMap;
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    
    	}
    
    	/**
    	 * 获取公钥
    	 * 
    	 * @param keyMap
    	 * @return
    	 */
    	public static byte[] getPublicKey(Map<String, Object> keyMap) {
    		DSAPublicKey key = (DSAPublicKey) keyMap.get(DSA_PUBLIC_KEY);
    		return key.getEncoded();
    	}
    
    	/**
    	 * 获取私钥
    	 * 
    	 * @param keyMap
    	 * @return
    	 */
    	public static byte[] getPrivateKey(Map<String, Object> keyMap) {
    		DSAPrivateKey key = (DSAPrivateKey) keyMap.get(DSA_PRIVATE_KEY);
    		return key.getEncoded();
    	}
    
    	/**
    	 * 对 原始数据 用 私钥 进行签名
    	 * 
    	 * @param data
    	 *            要签名的数据
    	 * @param privateKey
    	 *            私钥
    	 * @return
    	 */
    	public static byte[] sign(byte[] data, byte[] privateKey) {
    		try {
    			PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
    			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    			PrivateKey priKey = keyFactory.generatePrivate(keySpec);
    
    			Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    			signature.initSign(priKey);
    			signature.update(data);
    			return signature.sign();
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    
    	}
    
    	/**
    	 * 根据 原始数据、公钥、签名值 进行验证
    	 * 
    	 * @param data
    	 *            原始数据
    	 * @param publicKey
    	 *            公钥
    	 * @param sign
    	 *            签名
    	 * @return
    	 */
    	public static boolean verify(byte[] data, byte[] publicKey, byte[] sign) {
    		try {
    			X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
    			KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    			PublicKey pubKey = keyFactory.generatePublic(keySpec);
    
    			Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    			signature.initVerify(pubKey);
    			signature.update(data);
    			boolean isValid = signature.verify(sign);
    			return isValid;
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    
    	}
    
    }

字节数组转16进制

public class BytesToHex {
    
    	public static String fromBytesToHex(byte[] resultBytes) {
    		StringBuilder builder = new StringBuilder();
    		for (int i = 0; i < resultBytes.length; i++) {
    			if (Integer.toHexString(0xFF & resultBytes[i]).length() == 1) {
    				builder.append("0").append(
    						Integer.toHexString(0xFF & resultBytes[i]));
    			} else {
    				builder.append(Integer.toHexString(0xFF & resultBytes[i]));
    			}
    		}
    		return builder.toString();
    	}
    
    }

测试代码

import java.util.Map;
    
    public class Test {
    	// 待加密的明文
    	public static final String DATA = "test";
    
    	public static void main(String[] args) throws Exception {
    		// Test DSASignature
    		// 初始化密钥对
    		Map<String, Object> keyMap = DSASignatureUtil.initKey();
    		byte[] dsaPublicKey = DSASignatureUtil.getPublicKey(keyMap);
    		byte[] dsaPrivateKey = DSASignatureUtil.getPrivateKey(keyMap);
    		System.out.println("DSASignature PublicKey : "
    				+ BytesToHex.fromBytesToHex(dsaPublicKey));
    		System.out.println("DSASignature PrivateKey : "
    				+ BytesToHex.fromBytesToHex(dsaPrivateKey));
    
    		// Sign
    		byte[] sign = DSASignatureUtil.sign(DATA.getBytes(), dsaPrivateKey);
    		System.out.println("DSA Sign : " + BytesToHex.fromBytesToHex(sign));
    
    		// Verify
    		boolean isValid = DSASignatureUtil.verify((DATA).getBytes(),
    				dsaPublicKey, sign);
    		System.out.println("DSA Verify : " + isValid);
    	}
    }

[20161213223907721]: /images/20220714/77a356c3d4d94a39abea67c2b246e175.png
[20161213223920897]: /images/20220714/7bc5a923c7844e128fca6779b695dfdc.png