userb.java

java版数字签名

package mytest;
import javax.crypto.Cipher;

import sun.misc.BASE64Decoder;
import sun.security.pkcs.EncodingException;

import java.security.*;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.InvalidKeySpecException;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.Random;
import java.util.StringTokenizer;
import java.io.*;
import java.math.BigInteger;
import java.io.*;
import java.net.*;
public class UserB {
	/**
     * 生成密钥对
     * @return KeyPair
     * @throws EncryptException
     */
    public static KeyPair generateKeyPair() throws Exception {
        try {
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",
                    new org.bouncycastle.jce.provider.BouncyCastleProvider());
            final int KEY_SIZE = 1024;//没什么好说的了，这个值关系到块加密的大小，可以更改，但是不要太大，否则效率会低
            keyPairGen.initialize(KEY_SIZE, new SecureRandom());
            KeyPair keyPair = keyPairGen.genKeyPair();
            return keyPair;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }
    /**
     * 生成公钥
     * @param modulus
     * @param publicExponent
     * @return RSAPublicKey
     * @throws EncryptException
     */
    public static RSAPublicKey generateRSAPublicKey(byte[] modulus, byte[] publicExponent) throws Exception {
        KeyFactory keyFac = null;
        try {
            keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (NoSuchAlgorithmException ex) {
            throw new Exception(ex.getMessage());
        }

        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(modulus), new BigInteger(publicExponent));
        try {
            return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
        } catch (InvalidKeySpecException ex) {
            throw new Exception(ex.getMessage());
        }
    }
    /**
     * 生成私钥
     * @param modulus
     * @param privateExponent
     * @return RSAPrivateKey
     * @throws EncryptException
     */
    public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus, byte[] privateExponent) throws Exception {
        KeyFactory keyFac = null;
        try {
            keyFac = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (NoSuchAlgorithmException ex) {
            throw new Exception(ex.getMessage());
        }

        RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(modulus), new BigInteger(privateExponent));
        try {
            return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
        } catch (InvalidKeySpecException ex) {
            throw new Exception(ex.getMessage());
        }
    }
    /**
     * 加密
     * @param key 加密的密钥
     * @param data 待加密的明文数据
     * @return 加密后的数据
     * @throws EncryptException
     */
    public static byte[] encrypt(Key key, byte[] data) throws Exception {
        try {
            Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.ENCRYPT_MODE, key);
            int blockSize = cipher.getBlockSize();//获得加密块大小，如：加密前数据为128个byte，而key_size=1024 加密块大小为127 byte,加密后为128个byte;因此共有2个加密块，第一个127 byte第二个为1个byte
            int outputSize = cipher.getOutputSize(data.length);//获得加密块加密后块大小
            int leavedSize = data.length % blockSize;
            int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;
            byte[] raw = new byte[outputSize * blocksSize];
            int i = 0;
            while (data.length - i * blockSize > 0) {
                if (data.length - i * blockSize > blockSize)
                    cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);
                else
                    cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);
//这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了OutputSize所以只好用dofinal方法。

                i++;
            }
            return raw;
        } catch (Exception e) {
            throw new Exception(e.getMessage());
        }
    }
    /**
     * 解密
     * @param key 解密的密钥
     * @param raw 已经加密的数据
     * @return 解密后的明文
     * @throws EncryptException
     */
    public static byte[] decrypt(Key key, byte[] raw) throws EncodingException {
        try {
            Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());
            cipher.init(Cipher.DECRYPT_MODE, key);
            int blockSize = cipher.getBlockSize();
            ByteArrayOutputStream bout = new ByteArrayOutputStream(64);
            int j = 0;

            while (raw.length - j * blockSize > 0) {
                bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
                j++;
            }
            return bout.toByteArray();
        } catch (Exception e) {
            throw new EncodingException(e.getMessage());
        }
    }
    /**
	  * 
	  * 二行制转字符串  * 
	  * 一个字节的数， 转成16进制字符串
	  * 
	  * @param b
	  * 
	  * @return
	  */
	  
	 public static String byte2hex(byte[] b) { 
	  
	  String hs = "";
	  String stmp = "";
	  for (int n = 0; n < b.length; n++) {
	   // 整数转成十六进制表示
	   stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
	   if (stmp.length() == 1)
	    hs = hs + "0" + stmp;
	   else
	    hs = hs + stmp;
	  }
	  return hs.toUpperCase(); // 转成大写
	 }
	 
	 /**
	  * 
	  * 十六進制字符串转二行制  * 
	  *  
	  * @param b
	  * 
	  * @return
	  */
	 public static byte[] hex2byte(byte[] b) {
	  if ((b.length % 2) != 0)
	   throw new IllegalArgumentException("长度不是偶数");
	  byte[] b2 = new byte[b.length / 2];
	  for (int n = 0; n < b.length; n += 2) {
	   String item = new String(b, n, 2);
	   // 两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个进制字节
	   b2[n / 2] = (byte) Integer.parseInt(item, 16);
	  }
	  return b2;
	 }
	 
	 
	 public static byte[] getMessageDigest(byte[] by) throws Exception {
		// 使用getInstance("算法")来获得消息摘要,这里使用MD5算法
		MessageDigest messageDigest = MessageDigest.getInstance("MD5");
		messageDigest.update(by);// 开始使用算法
		return messageDigest.digest(); // 算法运算结果
	}
		
	 
    public static void main(String[] args) throws Exception{
    	try{
    		ServerSocket server=new ServerSocket(23456,100);
    		System.out.println("等待A:");
    		Socket connection=server.accept();
    		
    		ObjectOutputStream output=new ObjectOutputStream(connection.getOutputStream());
			output.flush();
			ObjectInputStream input =new ObjectInputStream(connection.getInputStream());
			
			KeyPair keyPair = UserA.generateKeyPair();
	        RSAPublicKey pubKey = (RSAPublicKey) keyPair.getPublic();
	        RSAPrivateKey priKey = (RSAPrivateKey) keyPair.getPrivate();
	        System.out.println("B产生密钥公钥："+byte2hex(pubKey.getEncoded()));
	        System.out.println("B产生密钥私钥："+byte2hex(priKey.getEncoded()));
			
	        RSAPublicKey pubKeyA=(RSAPublicKey)input.readObject();
			System.out.println("A的公钥为："+byte2hex(pubKeyA.getEncoded()));
	        
			System.out.println("发送B的公钥给A...");
			output.writeObject(pubKey);
			output.flush();
			
			byte[] receive=(byte[])input.readObject();
			String a=new String(receive);
			
			System.out.println("接受A的密文:"+a);
			byte[]receiveMsg=UserB.decrypt(priKey, receive);
			System.out.println("解密后的密文:"+new String(receiveMsg));

	       //解析传来的数据流
	        String b=new String(receiveMsg);
			StringTokenizer tokenizer=new StringTokenizer(b,"*");
			String raw=tokenizer.nextToken();//加密后的信息摘要
			String orgData=tokenizer.nextToken();//明文信息
			System.out.println("信息摘要为："+raw);
			System.out.println("明文为："+orgData);
			BASE64Decoder dec = new sun.misc.BASE64Decoder(); //64位编码解码
			byte[] signed = dec.decodeBuffer(raw);
			byte[] outDigest = getMessageDigest(dec.decodeBuffer(orgData));
		
			
			//解密后的明文写入文件decrypt.txt
			File file = new File("decrypt.txt");
	        OutputStream out = new FileOutputStream(file);
	        out = new FileOutputStream(file);
	        out.write(dec.decodeBuffer(orgData));
	        out.close();
			
			//验证数字签名
			Signature signetcheck=Signature.getInstance("MD5withRSA");
			signetcheck.initVerify(pubKeyA);
			signetcheck.update(outDigest);
			if (signetcheck.verify(signed)) {//如果签名得到验证，则返回 true，否则将返回 false
				System.out.println("验证成功");
			}
			
			output.close();
			input.close();
			connection.close();
    	}
    	catch(Exception e){
    		e.printStackTrace();
    	}
    }
}