本文大纲
一、提出问题
二、数字签名
三、实现步骤
四、参考代码
五、后记
六、参考资料
一、提出问题
最近在做一个项目，需要对一个现成的产品的数据库进行操作，增加额外的功能。为此，需要对该产品对数据库有什么操作进行研究（至于怎么监控一个产品的操作会引发什么数据库操作，以后会详细解说）。本来已经对数据库的操作了如指掌的，无意中发现数据库表里的每条记录都会有这样一个字段：
这感觉不妙了，字段名叫signature，顾名思义，就是签名的意思呀。难道数据库表中的每条记录都会有签名？也就是说如果我不能正确生成签名，而直接改记录中的字段，会被程序认为非法篡改了数据？那以后我的产品设计，是否也可采用这种方式来对每条记录做签名，防止数据被非法篡改，例如日志表中的数据？抱着这一发现以及这一连串的问题，我进行了以下的研究。在这里我将研究整理了一下，分享给大家。
二、数字签名
要解决上面的问题，首先就要对最基础的知识进行了解。这里最基础的知识，无疑就是什么是数字签名了。很多同学可能对这个名词并不陌生，但估计大多数人都是对其一知半解，会把散列、非对称加密、数字签名、数字证书的几个概念混为一谈，造成混乱。所以我先对相关概念进行解释，再往下讲。如果很熟悉这方面的同学可以跳过此部分，但对于绝大多数同学来说，不建议这样做。基础没搭好，直接看怎么实现，换了个说法又不知道怎么去做了。要想提高个人能力，做到举一反三很重要。
言归正传，先对跟数字签名有关的密码学知识简单说一下。加密方法分两大类，分别是单钥加密和双钥加密，数字签名涉及到双钥加密。关于双钥加密，主要涉及到以下几个要点[1]：
- 双钥加密的密钥有两把，一把是公开的公钥，一把是不公开的私钥
- 公钥和私钥是一一对应的关系，有一把公钥就必然有一把与之对应的、独一无二的私钥，反之亦成立。
- 所有的（公钥, 私钥）对都是不同的。
- 用公钥可以解开私钥加密的信息，反之亦成立。
- 同时生成公钥和私钥应该相对比较容易，但是从公钥推算出私钥，应该是很困难或者是不可能的。
- 在双钥体系中，公钥用来加密信息，私钥用来数字签名。
- 还有一点关于数字证书的。因为任何人都可以生成自己的公钥私钥对，所以为了防止有人散布伪造的骗取信任，就需要一个可靠的第三方机构来生成经过认证的公钥、私钥对。简单来说，数字证书是权威的第三方机构颁发的，用来认证某对公钥私钥的证书，经过这个数字证书认证的公钥私钥，就可以明确属于某人或者某机构，是合法的，可信任的。就如同身份证，是证明你身份的一个证件。所以数字证书跟数字签名是两回事，要分清楚。
数字签名，顾名思义，就类似于一种写在纸上的普通的物理签名，不同的是，数字签名是电子信息化的，采用双钥加密的技术实现，是一种用于鉴别数字信息的方法。处理的过程，简单说就是将文件内容进行hash散列，信息发送者对散列后的字符串使用私钥加密，得到的最终字符串就是签名。然后将得到的签名字符串添加到文件信息的后面一同发送出去。接收者获取到文件信息和签名后，使用公钥对签名进行解密，就得到文件内容加密后的hash散列。此时，他可以对获取到的文件内容做hash散列，与签名中的hash散列进行匹对，从而鉴别出最终获取信息的真伪。主要过程如这四幅图所示[2]：
对文件内容进行hash散列，生成摘要
对生成的摘要，使用私钥进行加密，形成签名
将得到的签名，附到文件内容后部，就想到与签名签到文件尾部那样子
使用公钥对签名进行解密，得到摘要，并与获取到的文件内容生成的摘要做对比，以确定是否被篡改
想了解更详细的数字证书相关内容，可以访问此地址：http://www.youdzone.com/signature.html。里面解释得很形象，应该一看就明白的了。
三、实现步骤
看到这里，开篇提出的问题也就呼之欲出了。没错，就是使用数字签名技术，将数据库中的重要字段进行签名，将签名结果作为记录的一列存在记录中。这样当有人入侵数据库，恶意修改字段，程序读数据时拿签名校验一下，就知道数据是否有被修改过了。
在java.security包中，有很多有用的类，用以进行安全机制的开发。对于要创建数字签名，我们主要用到以下的接口或类：
|
接口名 |
描述 |
|
privatekey |
a private key |
|
publickey |
a public key |
接口
|
类名 |
描述 |
|
signature |
the signature class is used to provide applications the functionality of a digital signature algorithm. |
|
keypair |
this class is a simple holder for a key pair (a public key and a private key) |
|
keypairgenerator |
the keypairgenerator class is used to generate pairs of public and private keys. |
类
对于接口和类的描述，我直接引用了oracle上的j2se 7的api描述[3]，就不翻译成中文了，以防词不达意。大家看英文应该能更精确的明白其意思。
利用上述的接口和类，就可以进行数字签名和验证了，下面分三部分进行基本步骤的描述。
第一部分：生成密钥并存储
- 生成keypairgenerator实例，并调用其genkeypair()方法生成keypair对象。
- 利用objectoutputstream实例，将keypair对象写到文件中，从而把密钥保存到文件中。
第二部分：进行数字签名
- 从密钥文件中读取keypair对象。
- 调用keypair对象的getprivate()和getpublic()方法，分别获取privatekey和publickey。
- 利用密钥的指定算法生成signature实例，然后利用privatekey和文件内容，分别调用其initsign()和update()方法，最后调用sign()方法生成数字签名。
第三部分：进行签名验证
- 从密钥文件中读取keypair对象。
- 调用keypair对象的getprivate()和getpublic()方法，分别获取privatekey和publickey。
- 利用密钥的指定算法生成signature实例，然后利用publickey和文件内容，分别调用其initsign()和update()方法，最后利用数字签名调用verify()方法验证签名。
四、参考代码
根据上面的步骤描述，基本可以写出程序来了。下面是参考代码，未必尽善尽美，但是基本功能都体现到了，供你参考。
工程结构：
datasecurity类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
package com.hzj.security;import java.io.unsupportedencodingexception;import java.nio.charset.charsetencoder;import java.security.keypair;import com.hzj.util.stringhelper;public class datasecurity { private keypair keypair; private static final string key_file = "/ca.key"; private datasignaturer datasignaturer; public datasecurity() { try { this.keypair = keypairutil.loadkeypair(getclass().getresourceasstream("/ca.key")); this.datasignaturer = new datasignaturer(this.keypair.getpublic(), this.keypair.getprivate()); } catch (runtimeexception e) { system.out.println("没有找到keypair文件[/ca.key]!"); } } /** * 验证数字签名 * @param data * @param signs * @return */ public boolean verifysign(string data, string signs) { if ((data == null) || (signs == null)) { system.out.println("参数为null"); } boolean verifyok = false; try { verifyok = this.datasignaturer.verifysign(data.getbytes("utf-8"), stringhelper.decryptbase64(signs)); } catch (runtimeexception e) { system.out.println("fail!data=" + data + ", sign=" + signs + ", exception:" + e.getmessage()); } catch (unsupportedencodingexception e) { system.out.println("不支持utf-8字符集"); } catch (exception e) { system.out.println("exception:" + e.getmessage()); } if (!verifyok) { system.out.println("fail!data=" + data + ", sign=" + signs + ", verifyok=false!"); } return verifyok; } /** * 生成数字签名 * @param data * @return */ public string sign(string data) { if (data == null) { system.out.println("参数为null"); } string sign = null; try { sign = stringhelper.encryptbase64(this.datasignaturer.sign(data.getbytes("utf-8"))); } catch (unsupportedencodingexception e) { system.out.println("不支持utf-8字符集"); } catch (exception e) { system.out.println(e.getmessage()); } return sign; } } |
datasignaturer类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
package com.hzj.security;import java.security.invalidkeyexception;import java.security.nosuchalgorithmexception;import java.security.privatekey;import java.security.publickey;import java.security.signature;import java.security.signatureexception;public class datasignaturer { private privatekey privatekey; private publickey publickey; public datasignaturer(publickey publickey, privatekey privatekey){ this.privatekey = privatekey; this.publickey = publickey; } /** * 进行数字签名 * @param data * @return */ public byte[] sign(byte[] data) { if (this.privatekey == null) { system.out.println("privatekey is null"); return null; } signature signer = null; try { signer = signature.getinstance(this.privatekey.getalgorithm()); } catch (nosuchalgorithmexception e) { system.out.println(e.getmessage()); } try { signer.initsign(this.privatekey); } catch (invalidkeyexception e) { system.out.println(e.getmessage()); } try { signer.update(data); return signer.sign(); } catch (signatureexception e) { system.out.println(e.getmessage()); return null; } catch (nullpointerexception e) { system.out.println(e.getmessage()); return null; } } /** * 验证数字签名 * @param data * @param signature * @return */ public boolean verifysign(byte[] data, byte[] signature) { if (this.publickey == null) { system.out.println("publickey is null"); return false; } signature signer = null; try { signer = signature.getinstance(this.publickey.getalgorithm()); } catch (nosuchalgorithmexception e) { system.out.println(e.getmessage()); return false; } try { signer.initverify(this.publickey); } catch (invalidkeyexception e) { system.out.println(e.getmessage()); return false; } try { signer.update(data); return signer.verify(signature); } catch (signatureexception e) { system.out.println(e.getmessage()); return false; } }} |
keypair类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
package com.hzj.security;import java.io.filenotfoundexception;import java.io.ioexception;import java.io.inputstream;import java.io.objectinputstream;import java.io.objectoutputstream;import java.io.outputstream;import java.security.keypair;import java.security.keypairgenerator;import java.security.nosuchalgorithmexception;public class keypairutil { // 采用的双钥加密算法，既可以用dsa，也可以用rsa public static final string key_algorithm = "dsa"; /** * 从输入流中获取keypair对象 * @param keypairstream * @return */ public static keypair loadkeypair(inputstream keypairstream) { if (keypairstream == null) { system.out.println("指定的输入流=null!因此无法读取keypair!"); return null; } try { objectinputstream ois = new objectinputstream(keypairstream); keypair keypair = (keypair) ois.readobject(); ois.close(); return keypair; } catch (exception e) { system.out.println(e.getmessage()); } return null; } /** * 将整个keypair以对象形式存储在outputstream流中， 当然也可以将publickey和privatekey作为两个对象分别存到两个outputstream流中， * 从而私钥公钥分开，看需求而定。 * @param keypair 公钥私钥对对象 * @param out 输出流 * @return */ public static boolean storekeypair(keypair keypair, outputstream out) { if ((keypair == null) || (out == null)) { system.out.println("keypair=" + keypair + ", out=" + out); return false; } try { objectoutputstream oos = new objectoutputstream(out); oos.writeobject(keypair); oos.close(); return true; } catch (filenotfoundexception e) { system.out.println(e.getmessage()); } catch (ioexception e) { system.out.println(e.getmessage()); } return false; } /** * 生成keypair公钥私钥对 * * @return */ public static keypair initkeypair() throws nosuchalgorithmexception{ keypairgenerator keypairgen = keypairgenerator.getinstance(key_algorithm); keypairgen.initialize(1024); return keypairgen.genkeypair(); } /** * 生成密钥，并存储 * @param out * @return * @throws nosuchalgorithmexception */ public static boolean initandstorekeypair(outputstream out) throws nosuchalgorithmexception { return storekeypair(initkeypair(), out); }} |
stringhelper类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package com.hzj.util;import sun.misc.base64encoder;import sun.misc.base64decoder;public class stringhelper { /** * base64encoder 加密 * @param data 要加密的数据 * @return 加密后的字符串 */ public static string encryptbase64(byte[] data) { base64encoder encoder = new base64encoder(); string encode = encoder.encode(data); return encode; } /** * base64decoder 解密 * @param data 要解密的字符串 * @return 解密后的byte[] * @throws exception */ public static byte[] decryptbase64(string data) throws exception { base64decoder decoder = new base64decoder(); byte[] buffer = decoder.decodebuffer(data); return buffer; } } |
program类：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
package com.hzj.main;import java.io.file;import java.io.filenotfoundexception;import java.io.fileoutputstream;import java.security.nosuchalgorithmexception;import com.hzj.security.datasecurity;import com.hzj.security.keypairutil;public class program { public static void main(string[] args) { // 1.生成证书// file file = new file("ca.key");// try {// fileoutputstream fileoutputstream = new fileoutputstream(file);// keypairutil.initandstorekeypair(fileoutputstream);// } catch (filenotfoundexception | nosuchalgorithmexception e) {// e.printstacktrace();// } // 2.生成数字签名// datasecurity datasecurity = new datasecurity();// string sign = datasecurity.sign("大家好");// system.out.println("sign:" + sign); //3.验证数字签名 datasecurity datasecurity = new datasecurity(); boolean result = datasecurity.verifysign("大家好", "mcwcfcds3sbw/fxk9flndl0m5lauipyfahr9vynnc91uiubxfwk3gzlljwgtkq=="); system.out.println("result：" + result); }} |
这里需要注意的是，为什么要对数字签名进行进行base64编码呢？这是因为生成的数字签名是byte[]型的，无论对应哪一种字符集来转化成string，都会有乱码出现。所以，采用base64进行编码，就可以得到一串可见的字符串，方便存储和重新调用。
五、后记
写到这里，本文的内容就基本上完结了。有人看到这里就会问，这不是说数据库记录防篡改嘛，一直都在讲数字签名，究竟怎么个防篡改？前文已经对数字签名的一些基本原理，使用的场景，开发的步骤、代码等进行了描述，开篇是也描述了项目中遇到的数据库中的问题。将这些信息综合起来，应该就知道怎么将数字签名应用到数据库记录中来作为数据库防篡改的工具了。知道工具怎么用是基础，会用工具来完成自己想做的事情，就是进阶了。祝你步步高升！
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持服务器之家！
原文链接：http://www.cnblogs.com/huangzijian/p/6347293.html
