Java加密与解密（by quqi99）

来源：互联网发布：爱淘宝 1元红包编辑：程序博客网时间：2024/06/05 11:41

Java加密与解密（by quqi99）

作者：张华发表于：2009-12-31

1）base64算法

加密：new BASE64Encoder().encode(byte[] b)

解密: new BASE64Decoder().decode(byte[] b)

2) MD5或SHA摘要

MessageDigest digest = MessageDigest.getInstance("SHA"); //若是md5就 "MD5"

digest.update(byte[] b);

sha.degest();

3) 字节与16进制互换。

String strDigits = "0123456789ABCDEF";

String strDigitArr = {"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F");

public String byte2Hex(byte[] bytes){

String hs = "";

String stmp = "";

for(int =0;n<bytes.length;n++){

stmp = (Integer.toHexString(bytes[n] & 0XFF));

if(stmp.length() == 1)

hs = hs + "0" + stmp;

else

hs = hs + stmp;

}

return hs.toUpperCase();

}

public byte[] hex2Str(String hexStr){

char[] hexs = hexStr.toCharArray();

byte[] bytes = new byte[hexStr.length()/2];

int n;

for(int i=0;i<bytes.length;i++){

n = strDigits.indexOf(hexs[2*i]) * 16;

n += strDigits.indexOf(hexs[2*i + 1]);

bytes[i] = (byte)(n & 0xff);

}

4) RSA有公钥与密钥

生成密钥对：

private KeyPair generateKeyPair(){

KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");

gen.initialize(1024,new SecureRandom());

KeyPari key = gen.genKeyPair();

return key;

}

//从公钥字节恢复公钥

//从密钥字节恢复密钥与这差不多，只不过将public字眼换成private

private RSAPublicKey recoverRSAPublicKey(byte[] modulus, byte[] publicExponent){

RSAPublicKeySpec spec = new RSAPublicKeySpec(new BigInteger(modulus),new BigInteger(publicExponent));

KeyFactory fac = KeyFacotry.getInstance("RSA");

RSAPublicKey key = (RSAPublicKey)fac.generatePublic(spec);

return key;

}

//RSA加解密

private byte[] rsaTrans(int mode,Key key,byte[] data){

if(mode != Cipher.ENCRYPT_MODE && mode!=Cipher.DECRYPT_MODE)

throw new Exception("");

Cipher cipher = Cipher.getInstance("RSA");

cipher.init(mode,key,new SecureRandom());

return cipher.doFinal(data);

}

使用上述的方法：

KeyPair keyPair = generateKeyPair();

RSAPublicKey pubKey = (RSAPublicKey)keyPair.getPublic();

RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();

byte[] pubModulusBytes = pubKey.getModulus().toByteArray();

byte[] publicExponentBytes = pubKey.getPublicExponent().toByteArray();

byte[] privateModulusBytes = privateKey.getModulus().toByteArray();

byte[] privateExponentBytes = privateKey.getPrivateExponent().toByteArray();

pubKey = recoverRSAPublicKey(pubModulusBytes,publicExponentBytes); //恢复公钥，恢复密钥类似

//用私钥加密

byte[] encryptData = rsaTran(Cipher.ENCRYPT_MODE,privateKey,bytes));

//用公钥解密

encryptData = rsaTran(Cipher.DECRYPT_MODE,privateKey,bytes));

5) DES为单钥加密机制，加密过程与RSA差不多。

步骤1：生成一个安全密匙。在加密或解密任何数据之前需要有一个密匙。密匙是随同被加密的应用一起发布的一小段数据

import java.security.SecureRandom;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
public class GenerateKey
{
static public void main( String args[] ) throws Exception {
    String keyFilename = "key.data";
    String algorithm = "DES";
    // 生成密匙
    SecureRandom sr = new SecureRandom();
    KeyGenerator kg = KeyGenerator.getInstance( algorithm );
    kg.init( sr );
    SecretKey key = kg.generateKey();//[-68, -68, -57, -71, 42, -125, 32, 13]
    // 把密匙数据保存到文件
    Util.writeFile( keyFilename, key.getEncoded() );
}
}

步骤2：加密数据。得到密匙之后，接下来就可以用它加密数据。

 // DES算法要求有一个可信任的随机数源



    SecureRandom sr = new SecureRandom();



    byte rawKeyData[] = /* 用某种方法获得密匙数据 */;



    // 从原始密匙数据创建DESKeySpec对象



    DESKeySpec dks = new DESKeySpec( rawKeyData );



    // 创建一个密匙工厂，然后用它把DESKeySpec转换



    // 一个SecretKey对象



    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );



    SecretKey key = keyFactory.generateSecret( dks );



    // Cipher对象实际完成加密操作



    Cipher cipher = Cipher.getInstance( "DES" );



    // 用密匙初始化Cipher对象



    cipher.init( Cipher.ENCRYPT_MODE, key, sr )



    // 现在，获取数据并加密



    byte data[] = /* 用某种方法获取数据 */



    // 正式执行加密操作



    byte encryptedData[] = cipher.doFinal( data );



    // 进一步处理加密后的数据







步骤3：解密数据。



   在上述加密数据将



  cipher.init( Cipher.ENCRYPT_MODE, key, sr );



  一句换成



 cipher.init( Cipher.DECRYPT_MODE, key, sr );



 doSomething( encryptedData );



















下面附一个练习的例子，写的一个License，代码如下：



import java.io.BufferedReader;



import java.io.File;



import java.io.FileInputStream;



import java.io.FileOutputStream;



import java.io.IOException;



import java.io.InputStreamReader;



import java.io.ObjectInputStream;



import java.io.ObjectOutputStream;



import java.security.SecureRandom;



import java.text.SimpleDateFormat;



import java.util.Date;



import javax.crypto.Cipher;



import javax.crypto.KeyGenerator;



import javax.crypto.SecretKey;



import javax.crypto.SecretKeyFactory;



import javax.crypto.spec.DESKeySpec;



/**







 * @version 0.10 2010-2-28



 * @author Zhang Hua



 * 利用license机制来保护Java软件产品的安全



 */



public class License {



private static final String licensePath = "license.dat";



private static final String keyFilename = "key.data";



private static SimpleDateFormat sdf  = new SimpleDateFormat( "yyyy-MM-dd");   //yyyy-MM-dd HH:mm:ss



//Product.title , AppServer



private String title = "AppServer";



//Product.sku, J2EE/CORBA



private String sku  = "J2EE/CORBA";



//Serial.number, MAC Address



private byte[] serialNumber;



//Platform, all



private String platform  = "";



//Trial.license



private boolean isTrial;



//License.expiry, 2010-05-12



private String expiry = "";



//Test



public static void main(String[] args){



//为用户生成license,并email给他



License om = new License();



om.setTitle("AppServer");



om.setSku("J2EE/CORBA");



String mac = getMACAddress();



om.setPlatform("Windows");



om.setTrial(false);



om.setExpiry("2010-05-12");



License.generateLicense(om,mac);



//在程序中校验license



License.validate();



}







//为用户生成license, 也就是将serialNumber字段的MAC加密



public static License generateLicense(License om,String mac){



    try{



    //密匙不存在，则生成密匙



            if(! new File(keyFilename).exists()){



            generateKey();    



}



    //用密匙加密数据



    byte rawKeyData[] = readFile(keyFilename);        //用某种方法获得密匙数据 



    DESKeySpec dks = new DESKeySpec( rawKeyData );    //从原始密匙数据创建DESKeySpec对象



    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); //创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象



    SecretKey key = keyFactory.generateSecret( dks );



    Cipher cipher = Cipher.getInstance( "DES" );      //Cipher对象实际完成加密操作



    SecureRandom sr = new SecureRandom();             //DES算法要求有一个可信任的随机数源



    cipher.init(Cipher.ENCRYPT_MODE, key, sr );       //用密匙初始化Cipher对象



    byte data[] = mac.getBytes();    //用某种方法获取数据 



    byte encryptedData[] = cipher.doFinal( data );    //正式执行加密操作



    System.out.println("加密后的数据：" + encryptedData);



    om.setSerialNumber(encryptedData);



    //输出license



    write(om);



    }catch(Exception e){



    e.printStackTrace();



    }



return om;



}







//生成密匙



private static boolean generateKey(){



boolean result = false'



String algorithm = "DES";



try{



    SecureRandom sr = new SecureRandom();              //DES算法要求有一个可信任的随机数源



    KeyGenerator kg = KeyGenerator.getInstance(algorithm);



    kg.init( sr );



    SecretKey key = kg.generateKey();                  //[-68, -68, -57, -71, 42, -125, 32, 13]



    result = writeFile(keyFilename, key.getEncoded()); //把密匙数据保存到文件



}catch(Exception e){



e.printStackTrace();



}



return result;



}











public static boolean validate(){



boolean result = false;



try{



License om = read()'



String os = System.getProperty("os.name");



if (os.toLowerCase().startsWith(om.getPlatform().toLowerCase()) || "all".equals(om.getPlatform())) {



Date expireDate = sdf.parse(om.getExpiry());



if(expireDate.getTime() - new Date().getTime() < 0){



System.err.println("License过期了");



result = false'



}else{



if(om.isTrial()){



System.out.println("试用License有效");



result = true;



}else{



String mac = getMACAddress();



//用密匙解密数据



    byte rawKeyData[] = readFile(keyFilename);        //用某种方法获得密匙数据 



    DESKeySpec dks = new DESKeySpec( rawKeyData );    //从原始密匙数据创建DESKeySpec对象



    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); //创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象



    SecretKey key = keyFactory.generateSecret( dks );



    Cipher cipher = Cipher.getInstance( "DES" );      //Cipher对象实际完成加密操作



    SecureRandom sr = new SecureRandom();             //DES算法要求有一个可信任的随机数源



    cipher.init(Cipher.DECRYPT_MODE, key, sr );       //用密匙初始化Cipher对象



    byte data[] = om.getSerialNumber();               //用某种方法获取数据 



    byte encryptedData[] = cipher.doFinal(data);      //正式执行加密操作



    String tmp = new String(encryptedData);



    System.out.println("解密后的数据：" + tmp);



    if(mac.equals(tmp)){



    System.out.println("License有效");



    result = true;



    }else{



    System.err.println("License无效");



    result = false;



    }



}



}



}else{



System.err.println("License的平台无效");



    result = false;



}



}catch(Exception e){



e.printStackTrace();



}



return result;



}







public static License read(){



License om = null;



try{



om = new License();



ObjectInputStream in = new ObjectInputStream(new FileInputStream(licensePath));



om.setTitle((String)in.readObject());



om.setSku((String)in.readObject());



om.setPlatform((String)in.readObject());



om.setTrial(in.readBoolean());



om.setExpiry((String)in.readObject());



om.setSerialNumber((byte[])in.readObject());



in.close();



}catch(Exception e){



e.printStackTrace();



}



return om;



}











public static boolean write(License om){



boolean result;



try{



File f = new File(licensePath);



if(f.exists())



f.delete();



ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));



out.writeObject(om.getTitle());



out.writeObject(om.getSku());



out.writeObject(om.getPlatform());



out.writeBoolean(om.isTrial());



out.writeObject(om.getExpiry());



out.writeObject(om.getSerialNumber());



out.close();



                       result = true;



}catch(Exception e){



e.printStackTrace();



result = false;



}



return result;



}































public static boolean writeFile(String path, byte[] bytes){















boolean result = false;















try {















FileOutputStream   fos = new FileOutputStream(path);















fos.write(bytes);















fos.close();















result = true;















} catch (Exception e) {















e.printStackTrace();















}   















return result;















}































public static byte[] readFile(String path){















byte[] bytes = null;















try {















FileInputStream   fin = new FileInputStream(path);















bytes = new byte[fin.available()];















fin.read(bytes);















fin.close();















} catch (Exception e) {















e.printStackTrace();















}   















return bytes;















}































































  public static String getMACAddress() {















String address = "";















String os = System.getProperty("os.name");















if (os.startsWith("Windows")) {















try {















String command = "cmd.exe /c ipconfig /all";















Process p = Runtime.getRuntime().exec(command);















BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));















String line;















while ((line = br.readLine()) != null) {















if (line.indexOf("Physical Address") > 0) {















int index = line.indexOf(":");















index += 2;















address = line.substring(index);















break;















}















}















br.close();















return address.trim();















} catch (IOException e) {















e.printStackTrace();















}















} else if (os.startsWith("Linux")) {















String command = "/bin/sh -c ifconfig -a";















Process p;















try {















p = Runtime.getRuntime().exec(command);















BufferedReader br = new BufferedReader(new InputStreamReader(p















.getInputStream()));















String line;















while ((line = br.readLine()) != null) {















if (line.indexOf("HWaddr") > 0) {















int index = line.indexOf("HWaddr") + "HWaddr".length();















address = line.substring(index);















break;















}















}















br.close();















} catch (IOException e) {















e.printStackTrace();







}







}







address = address.trim();



return address;



}











public String getTitle() {



return title;



}



public void setTitle(String title) {







this.title = title;



}



public String getSku() {



return sku;



}



public void setSku(String sku) {



this.sku = sku;



}



public byte[] getSerialNumber() {



return serialNumber;



}



public void setSerialNumber(byte[] serialNumber) {



this.serialNumber = serialNumber;



}







public String getPlatform() {



return platform;



}



public void setPlatform(String platform) {



this.platform = platform;



}







public boolean isTrial() {



return isTrial;



}



public void setTrial(boolean isTrial) {



this.isTrial = isTrial;



}



public String getExpiry() {



return expiry;



}



public void setExpiry(String expiry) {



this.expiry = expiry;



}



}















关于license的生成，还想说几点：



1）无论是生成二进制license，还是文件的，最好带上指纹校验。



2）无论是用什么加密算法无所谓，问题的关键不在里，在于JAVA容易被反编译，反编译之后很容易看到你的加密算法，人家可以



   把这块替掉或者删除掉。另外，人家也可以在主程序调用license处的地方反编译之后直接返回true。



    有网友说，对JAR包加密，然后自定义classloader解密，我看也是不行的，因为你自定义的classloader也是很容易被



    反编译的，那样你的解密过程也就都清楚了。



    所以，我认为，JAVA的东西就应用是开源的。当然，我们可以用混淆工具进行一定程度的混淆，算是给反编译增中一点困难的。



3）我试用了混淆工具proguard，觉得混淆工具有点不满足我的需求。



     它默认是都混淆，但可以通过-keep参数指定某些类某些方法不混淆。



     而我的需求是大多数类我不想混淆，我只想对少数几个类混淆，而且我的程序非常大，如果按照它的通过-keep参数指定



     我不想混淆的类是不是有点太麻烦了。



     下面是一个我测试过程中算是比较通用的配置my.conf，它对public,protected都不进行混淆，



用java -cp .;test.jar -jar proguard.jar @E:/workspace/test/my.conf 可执行混淆操作，my.conf文件如下：



      -injars       E:/workspace/test/test.jar



-outjars      E:/workspace/test/test_out.jar



-libraryjars  <java.home>/lib/rt.jar



-libraryjars  E:/workspace/test/lib/mail.jar



-printmapping proguard.map







-renamesourcefileattribute SourceFile



-keepattributes Exceptions,InnerClasses,Signature,Deprecated,



                SourceFile,LineNumberTable,*Annotation*,EnclosingMethod







-keep public class org.** 











-keep public class * {



    public protected *;



}







-keepclassmembernames class * {



    java.lang.Class class$(java.lang.String);



    java.lang.Class class$(java.lang.String, boolean);



}







-keepclasseswithmembernames class * {



    native <methods>;



}







-keepclassmembers enum * {



    public static **[] values();



    public static ** valueOf(java.lang.String);



}







-keepclassmembers class * implements java.io.Serializable {



    static final long serialVersionUID;



    private void writeObject(java.io.ObjectOutputStream);



    private void readObject(java.io.ObjectInputStream);



    java.lang.Object writeReplace();



    java.lang.Object readResolve();



}











　一、密码学上常用的概念

　　1）消息摘要：

　　这是一种与消息认证码结合使用以确保消息完整性的技术。主要使用单向散列函数算法，可用于检验消息的完整性，和通过散列密码直接以文本形式保存等，目前广泛使用的算法有MD4、MD5、SHA-1，jdk1.5对上面都提供了支持，在java中进行消息摘要很简单， java.security.MessageDigest提供了一个简易的操作方法：
　　/**
　　*MessageDigestExample.java
　　*Copyright 2005-2-16
　　*/
　　import java.security.MessageDigest;
　　/**
　　*单一的消息摘要算法，不使用密码.可以用来对明文消息（如：密码）隐藏保存
　　*/
　　public class MessageDigestExample{
　　public static void main(String[] args) throws Exception{
　　if(args.length!=1){
　　　System.err.println("Usage:java MessageDigestExample text");
　　　System.exit(1);
　　}
　　byte[] plainText=args[0].getBytes("UTF8");
　　//使用getInstance("算法")来获得消息摘要,这里使用SHA-1的160位算法
　　MessageDigest messageDigest=MessageDigest.getInstance("SHA-1");
　　System.out.println(" "+messageDigest.getProvider().getInfo());
　　//开始使用算法
　　messageDigest.update(plainText);
　　System.out.println(" Digest:");
　　//输出算法运算结果
　　System.out.println(new String(messageDigest.digest(),"UTF8"));
　　}
　　}
　　还可以通过消息认证码来进行加密实现，javax.crypto.Mac提供了一个解决方案，有兴趣者可以参考相关API文档，本文只是简单介绍什么是摘要算法。
　　2）私钥加密：

　　消息摘要只能检查消息的完整性，但是单向的，对明文消息并不能加密，要加密明文的消息的话，就要使用其他的算法，要确保机密性，我们需要使用私钥密码术来交换私有消息。
　　这种最好理解，使用对称算法。比如：A用一个密钥对一个文件加密，而B读取这个文件的话，则需要和A一样的密钥，双方共享一个私钥（而在web环境下，私钥在传递时容易被侦听）：
　　使用私钥加密的话，首先需要一个密钥，可用javax.crypto.KeyGenerator产生一个密钥(java.security.Key),然后传递给一个加密工具(javax.crypto.Cipher),该工具再使用相应的算法来进行加密，主要对称算法有：DES（实际密钥只用到56位），AES（支持三种密钥长度：128、192、256位），通常首先128位，其他的还有DESede等，jdk1.5种也提供了对对称算法的支持，以下例子使用AES算法来加密：
　　/**
　　*PrivateExmaple.java
　　*Copyright 2005-2-16
　　*/
　　import javax.crypto.Cipher;
　　import javax.crypto.KeyGenerator;
　　import java.security.Key;
　　/**
　　*私鈅加密，保证消息机密性
　　*/
　　public class PrivateExample{
　　public static void main(String[] args) throws Exception{
　　if(args.length!=1){
　　　System.err.println("Usage:java PrivateExample ");
　　　System.exit(1);
　　}
　　byte[] plainText=args[0].getBytes("UTF8");
　　//通过KeyGenerator形成一个key
　　System.out.println(" Start generate AES key");
　　KeyGenerator keyGen=KeyGenerator.getInstance("AES");
　　keyGen.init(128);
　　Key key=keyGen.generateKey();
　　System.out.println("Finish generating DES key");
　　//获得一个私鈅加密类Cipher，ECB是加密方式，PKCS5Padding是填充方法
　　Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
　　System.out.println(" "+cipher.getProvider().getInfo());
　　//使用私鈅加密
　　System.out.println(" Start encryption:");
　　cipher.init(Cipher.ENCRYPT_MODE,key);
　　byte[] cipherText=cipher.doFinal(plainText);
　　System.out.println("Finish encryption:");
　　System.out.println(new String(cipherText,"UTF8"));
　　System.out.println(" Start decryption:");
　　cipher.init(Cipher.DECRYPT_MODE,key);
　　byte[] newPlainText=cipher.doFinal(cipherText);
　　System.out.println("Finish decryption:");
　　System.out.println(new String(newPlainText,"UTF8"));
　　}
　　}
　　3）公钥加密：

　　上面提到，私钥加密需要一个共享的密钥，那么如何传递密钥呢？web环境下，直接传递的话很容易被侦听到，幸好有了公钥加密的出现。公钥加密也叫不对称加密，不对称算法使用一对密钥对，一个公钥，一个私钥，使用公钥加密的数据，只有私钥能解开（可用于加密）；同时，使用私钥加密的数据，只有公钥能解开（签名）。但是速度很慢（比私钥加密慢100到1000倍），公钥的主要算法有RSA，还包括Blowfish,Diffie-Helman等，jdk1.5种提供了对RSA的支持，是一个改进的地方：
　　/**
　　*PublicExample.java
　　*Copyright 2005-2-16
　　*/
　　import java.security.Key;
　　import javax.crypto.Cipher;
　　import java.security.KeyPairGenerator;
　　import java.security.KeyPair;
　　/**
　　*一个简单的公鈅加密例子,Cipher类使用KeyPairGenerator生成的公鈅和私鈅
　　*/
　　public class PublicExample{
　　public static void main(String[] args) throws Exception{
　　if(args.length!=1){
　　　System.err.println("Usage:java PublicExample ");
　　　System.exit(1);
　　}
　　byte[] plainText=args[0].getBytes("UTF8");
　　//构成一个RSA密钥
　　System.out.println(" Start generating RSA key");
　　KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
　　keyGen.initialize(1024);
　　KeyPair key=keyGen.generateKeyPair();
　　System.out.println("Finish generating RSA key");
　　//获得一个RSA的Cipher类，使用公鈅加密
　　Cipher cipher=Cipher.getInstance("RSA/ECB/PKCS1Padding");
　　System.out.println(" "+cipher.getProvider().getInfo());
　　System.out.println(" Start encryption");
　　cipher.init(Cipher.ENCRYPT_MODE,key.getPublic());
　　byte[] cipherText=cipher.doFinal(plainText);
　　System.out.println("Finish encryption:");
　　System.out.println(new String(cipherText,"UTF8"));
　　//使用私鈅解密
　　System.out.println(" Start decryption");
　　cipher.init(Cipher.DECRYPT_MODE,key.getPrivate());
　　byte[] newPlainText=cipher.doFinal(cipherText);
　　System.out.println("Finish decryption:");
　　System.out.println(new String(newPlainText,"UTF8"));
　　}
　　}
　　4）数字签名：

　　数字签名，它是确定交换消息的通信方身份的第一个级别。上面A通过使用公钥加密数据后发给B，B利用私钥解密就得到了需要的数据，问题来了，由于都是使用公钥加密，那么如何检验是A发过来的消息呢？上面也提到了一点，私钥是唯一的，那么A就可以利用A自己的私钥进行加密，然后B再利用A的公钥来解密，就可以了；数字签名的原理就基于此，而通常为了证明发送数据的真实性，通过利用消息摘要获得简短的消息内容，然后再利用私钥进行加密散列数据和消息一起发送。java中为数字签名提供了良好的支持，java.security.Signature类提供了消息签名：
　　/**
　　*DigitalSignature2Example.java
　　*Copyright 2005-2-16
　　*/
　　import java.security.Signature;
　　import java.security.KeyPairGenerator;
　　import java.security.KeyPair;
　　import java.security.SignatureException;
　　/**
　　*数字签名，使用RSA私钥对对消息摘要签名，然后使用公鈅验证测试
　　*/
　　public class DigitalSignature2Example{
　　public static void main(String[] args) throws Exception{
　　if(args.length!=1){
　　　System.err.println("Usage:java DigitalSignature2Example ");
　　　System.exit(1);
　　}
　　byte[] plainText=args[0].getBytes("UTF8");
　　//形成RSA公钥对
　　System.out.println(" Start generating RSA key");
　　KeyPairGenerator keyGen=KeyPairGenerator.getInstance("RSA");
　　keyGen.initialize(1024);
　　KeyPair key=keyGen.generateKeyPair();
　　System.out.println("Finish generating RSA key");
　　//使用私鈅签名
　　Signature sig=Signature.getInstance("SHA1WithRSA");
　　sig.initSign(key.getPrivate());
　　sig.update(plainText);
　　byte[] signature=sig.sign();
　　System.out.println(sig.getProvider().getInfo());
　　System.out.println(" Signature:");
　　System.out.println(new String(signature,"UTF8"));
　　//使用公鈅验证
　　System.out.println(" Start signature verification");
　　sig.initVerify(key.getPublic());
　　sig.update(plainText);
　　try{
　　　if(sig.verify(signature)){
　　　　System.out.println("Signature verified");
　　　}else System.out.println("Signature failed");
　　　}catch(SignatureException e){
　　　　System.out.println("Signature failed");
　　　}
　　}
　　}

　　5)数字证书。

　　还有个问题，就是公钥问题，A用私钥加密了，那么B接受到消息后，用A提供的公钥解密；那么现在有个讨厌的C，他把消息拦截了，然后用自己的私钥加密，同时把自己的公钥发给B，并告诉B，那是A的公钥，结果....，这时候就需要一个中间机构出来说话了（相信权威，我是正确的），就出现了Certificate Authority(也即CA），有名的CA机构有Verisign等，目前数字认证的工业标准是：CCITT的X.509：
　　数字证书：它将一个身份标识连同公钥一起进行封装，并由称为认证中心或 CA 的第三方进行数字签名。
　　密钥库：java平台为你提供了密钥库，用作密钥和证书的资源库。从物理上讲，密钥库是缺省名称为 .keystore 的文件（有一个选项使它成为加密文件）。密钥和证书可以拥有名称（称为别名），每个别名都由唯一的密码保护。密钥库本身也受密码保护；您可以选择让每个别名密码与主密钥库密码匹配。
　　使用工具keytool，我们来做一件自我认证的事情吧（相信我的认证）：
　　1、创建密钥库keytool -genkey -v -alias feiUserKey -keyalg RSA 默认在自己的home目录下（windows系统是c:documents and settings<你的用户名> 目录下的.keystore文件），创建我们用 RSA 算法生成别名为 feiUserKey 的自签名的证书,如果使用了-keystore mm 就在当前目录下创建一个密钥库mm文件来保存密钥和证书。
　　2、查看证书：keytool -list 列举了密钥库的所有的证书
　　也可以在dos下输入keytool -help查看帮助。

　　 4）数字签名：