数字签名算法DSA

一、概述

1、DSA是以RSA为基础形成的

2、java6提供了DSA的实现，但是java6只提供了SHA1withDSA的实现

3、bouncycastle扩展提供了其他的DSA实现方式

4、遵循“私钥签名，公钥验证”的原则

二、模型分析

这个和RSA一样，只是换了一个算法而已

 

三、代码分析

[Java]  view plain  copy

1. package com.ca.test;  
2. import java.security.Key;  
3. import java.security.KeyFactory;  
4. import java.security.KeyPair;  
5. import java.security.KeyPairGenerator;  
6. import java.security.PrivateKey;  
7. import java.security.PublicKey;  
8. import java.security.SecureRandom;  
9. import java.security.Signature;  
10. import java.security.interfaces.DSAPrivateKey;  
11. import java.security.interfaces.DSAPublicKey;  
12. import java.security.spec.PKCS8EncodedKeySpec;  
13. import java.security.spec.X509EncodedKeySpec;  
14. import java.util.HashMap;  
15. import java.util.Map;  
16. import org.apache.commons.codec.binary.Base64;  
17.   
18. /** 
19.  * 常用数字签名算法DSA 
20.  * 数字签名 
21.  * @author kongqz 
22.  * */  
23. public class DSACoder {  
24.     //数字签名，密钥算法  
25.     public static final String KEY_ALGORITHM="DSA";  
26.       
27.     /** 
28.      * 数字签名 
29.      * 签名/验证算法 
30.      * */  
31.     public static final String SIGNATURE_ALGORITHM="SHA1withDSA";  
32.       
33.     /** 
34.      * DSA密钥长度，RSA算法的默认密钥长度是1024 
35.      * 密钥长度必须是64的倍数，在512到1024位之间 
36.      * */  
37.     private static final int KEY_SIZE=1024;  
38.     //公钥  
39.     private static final String PUBLIC_KEY="DSAPublicKey";  
40.       
41.     //私钥  
42.     private static final String PRIVATE_KEY="DSAPrivateKey";  
43.       
44.     /** 
45.      * 初始化密钥对 
46.      * @return Map 甲方密钥的Map 
47.      * */  
48.     public static Map<String,Object> initKey() throws Exception{  
49.         //实例化密钥生成器  
50.         KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);  
51.         //初始化密钥生成器  
52.         keyPairGenerator.initialize(KEY_SIZE,new SecureRandom());  
53.         //生成密钥对  
54.         KeyPair keyPair=keyPairGenerator.generateKeyPair();  
55.         //甲方公钥  
56.         DSAPublicKey publicKey=(DSAPublicKey) keyPair.getPublic();  
57.         //甲方私钥  
58.         DSAPrivateKey privateKey=(DSAPrivateKey) keyPair.getPrivate();  
59.         //将密钥存储在map中  
60.         Map<String,Object> keyMap=new HashMap<String,Object>();  
61.         keyMap.put(PUBLIC_KEY, publicKey);  
62.         keyMap.put(PRIVATE_KEY, privateKey);  
63.         return keyMap;  
64.           
65.     }  
66.       
67.       
68.     /** 
69.      * 签名 
70.      * @param data待签名数据 
71.      * @param privateKey 密钥 
72.      * @return byte[] 数字签名 
73.      * */  
74.     public static byte[] sign(byte[] data,byte[] privateKey) throws Exception{  
75.           
76.         //取得私钥  
77.         PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(privateKey);  
78.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
79.         //生成私钥  
80.         PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);  
81.         //实例化Signature  
82.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
83.         //初始化Signature  
84.         signature.initSign(priKey);  
85.         //更新  
86.         signature.update(data);  
87.         return signature.sign();  
88.     }  
89.     /** 
90.      * 校验数字签名 
91.      * @param data 待校验数据 
92.      * @param publicKey 公钥 
93.      * @param sign 数字签名 
94.      * @return boolean 校验成功返回true，失败返回false 
95.      * */  
96.     public static boolean verify(byte[] data,byte[] publicKey,byte[] sign) throws Exception{  
97.         //转换公钥材料  
98.         //实例化密钥工厂  
99.         KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);  
100.         //初始化公钥  
101.         //密钥材料转换  
102.         X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(publicKey);  
103.         //产生公钥  
104.         PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);  
105.         //实例化Signature  
106.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
107.         //初始化Signature  
108.         signature.initVerify(pubKey);  
109.         //更新  
110.         signature.update(data);  
111.         //验证  
112.         return signature.verify(sign);  
113.     }  
114.     /** 
115.      * 取得私钥 
116.      * @param keyMap 密钥map 
117.      * @return byte[] 私钥 
118.      * */  
119.     public static byte[] getPrivateKey(Map<String,Object> keyMap){  
120.         Key key=(Key)keyMap.get(PRIVATE_KEY);  
121.         return key.getEncoded();  
122.     }  
123.     /** 
124.      * 取得公钥 
125.      * @param keyMap 密钥map 
126.      * @return byte[] 公钥 
127.      * */  
128.     public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{  
129.         Key key=(Key) keyMap.get(PUBLIC_KEY);  
130.         return key.getEncoded();  
131.     }  
132.     /** 
133.      * @param args 
134.      * @throws Exception  
135.      */  
136.     public static void main(String[] args) throws Exception {  
137.         //初始化密钥  
138.         //生成密钥对  
139.         Map<String,Object> keyMap=DSACoder.initKey();  
140.         //公钥  
141.         byte[] publicKey=DSACoder.getPublicKey(keyMap);  
142.           
143.         //私钥  
144.         byte[] privateKey=DSACoder.getPrivateKey(keyMap);  
145.         System.out.println("公钥：/n"+Base64.encodeBase64String(publicKey));  
146.         System.out.println("私钥：/n"+Base64.encodeBase64String(privateKey));  
147.           
148.         System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");  
149.         String str="DSA数字签名算法";  
150.         System.out.println("原文:"+str);  
151.         //甲方进行数据的加密  
152.         byte[] sign=DSACoder.sign(str.getBytes(), privateKey);  
153.         System.out.println("产生签名："+Base64.encodeBase64String(sign));  
154.         //验证签名  
155.         boolean status=DSACoder.verify(str.getBytes(), publicKey, sign);  
156.         System.out.println("状态："+status+"/n/n");  
157.           
158.           
159.     }  
160. }  
161. 控制台输出：  
162. 公钥：  
163. MIIBtzCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZp  
164. RV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fn  
165. xqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuE  
166. C/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJ  
167. FnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImo  
168. g9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoDgYQAAoGAdLUOPbXqOQi4MFUm5tgBs2zQO20P7P1iPCC9  
169. pslWvixp13NX9dTwdddkwqQtwKAfm/Ao2Gqe7VGq48kTIPr0wz01LKlCLbbw6VLikuFcgVNN+sVx  
170. mwVTm54aFpiOaenS575Qtyek3zjVV+eMtRNKn91rMMWpsP6pucqku6xO5uY=  
171. 私钥：  
172. MIIBSwIBADCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2  
173. USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4  
174. O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmC  
175. ouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCB  
176. gLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhR  
177. kImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoEFgIUQhtJHLosUo0sxPKmCxC8NFVjD9c=  
178. ================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============  
179. 原文:DSA数字签名算法  
180. 产生签名：MCwCFAsJPC7xUfrvGYXtsxiWcS6GHAe1AhRnZLZ1CJe8I41vaScvJ7UZ8yk0oA==  
181. 状态：true  

四、总结

1、DSA的公钥长度略长于私钥，这个和RSA有较大差别。可以通过两个算法的控制台输出公钥私钥长度比对

2、DSA算法的签名长度与密钥长度无关。可能和待签名数据有联系...