使用数字签名实现数据库记录防篡改（Java实现）

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;

  }

  }

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 ;

  }

  }

}

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);

  }

}

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;

  }

}

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);

  }

}