数字签名算法RSA

文章转自：http://blog.csdn.net/kongqz/article/details/6305548

一、概述

1、数字签名算法可以看做是一个带有密钥的消息摘要算法，并且这个密钥包括了公钥和私钥。他是非对称加密算法和消息摘要算法的结合体

2、数字签名算法是公钥基础设施（PKI），以及许多网络安全机制的基础

3、数字签名算法有抗否认的作用

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

5、常见的数字签名算法有RSA/DSA/ECDSA

6、java6支持实现了DSA算法、部分RSA算法需要bouncycastle支持，最牛的ECDSA算法（微软用来做操作系统序列号的那个）完全需要Bouncycastle支持

二、模型分析

1、甲方构造密钥对（公钥+私钥），公布公钥给乙方

2、甲方使用私钥对数据进行签名，然后将“签名+数据” 发送给乙方

3、乙方使用公钥+数字签名 验证数据

 

三、代码分析

package com.pptv.activityapi.util.rsa;

import org.apache.commons.codec.binary.Base64;

import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * 经典的数字签名算法RSA
 * 数字签名
 * @author kongqz
 * */
public class RSACoder {
    //数字签名，密钥算法
    public static final String KEY_ALGORITHM="RSA";

    /**
     * 数字签名
     * 签名/验证算法
     * */
    public static final String SIGNATURE_ALGORITHM="MD5withRSA";

    /**
     * RSA密钥长度，RSA算法的默认密钥长度是1024
     * 密钥长度必须是64的倍数，在512到65536位之间
     * */
    private static final int KEY_SIZE=512;
    //公钥
    private static final String PUBLIC_KEY="RSAPublicKey";

    //私钥
    private static final String PRIVATE_KEY="RSAPrivateKey";

    /**
     * 初始化密钥对
     * @return Map 甲方密钥的Map
     * */
    public static Map<String,Object> initKey() throws Exception{
        //实例化密钥生成器
        KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密钥生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密钥对
        KeyPair keyPair=keyPairGenerator.generateKeyPair();
        //甲方公钥
        RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
        //甲方私钥
        RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
        //将密钥存储在map中
        Map<String,Object> keyMap=new HashMap<String,Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;

    }


    /**
     * 签名
     * @param data 待签名数据
     * @param privateKey 密钥
     * @return byte[] 数字签名
     * */
    public static byte[] sign(byte[] data,byte[] privateKey) throws Exception{

        //取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(privateKey);
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私钥
        PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);
        //实例化Signature
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        //初始化Signature
        signature.initSign(priKey);
        //更新
        signature.update(data);
        return signature.sign();
    }
    /**
     * 校验数字签名
     * @param data 待校验数据
     * @param publicKey 公钥
     * @param sign 数字签名
     * @return boolean 校验成功返回true，失败返回false
     * */
    public static boolean verify(byte[] data,byte[] publicKey,byte[] sign) throws Exception{
        //转换公钥材料
        //实例化密钥工厂
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公钥
        //密钥材料转换
        X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(publicKey);
        //产生公钥
        PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
        //实例化Signature
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        //初始化Signature
        signature.initVerify(pubKey);
        //更新
        signature.update(data);
        //验证
        return signature.verify(sign);
    }
    /**
     * 取得私钥
     * @param keyMap 密钥map
     * @return byte[] 私钥
     * */
    public static byte[] getPrivateKey(Map<String,Object> keyMap){
        Key key=(Key)keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    /**
     * 取得公钥
     * @param keyMap 密钥map
     * @return byte[] 公钥
     * */
    public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
        Key key=(Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //初始化密钥
        //生成密钥对
        Map<String,Object> keyMap=RSACoder.initKey();
        //公钥
        byte[] publicKey=RSACoder.getPublicKey(keyMap);

        //私钥
        byte[] privateKey=RSACoder.getPrivateKey(keyMap);
        System.out.println("公钥：/n"+Base64.encodeBase64String(publicKey));
        System.out.println("私钥：/n"+Base64.encodeBase64String(privateKey));

        System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");
        String str="RSA数字签名算法";
        System.out.println("原文:"+str);
        //甲方进行数据的加密
        byte[] sign=RSACoder.sign(str.getBytes(), privateKey);
        System.out.println("产生签名："+Base64.encodeBase64String(sign));
        //验证签名
        boolean status=RSACoder.verify(str.getBytes(), publicKey, sign);
        System.out.println("状态："+status+"/n/n");


    }
}

控制台输出：  
公钥：  
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJXmcnNTaWUnib5uMMQI2VCAq/rCPoFonlGHBVhDatRH  
GLEkZ2z/PiT1RxrmBdRxAb50LoNYGUOvOCieOJqU4B8CAwEAAQ==  
私钥：  
MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAleZyc1NpZSeJvm4wxAjZUICr+sI+  
gWieUYcFWENq1EcYsSRnbP8+JPVHGuYF1HEBvnQug1gZQ684KJ44mpTgHwIDAQABAkBUaU3f5YO/  
Q7GMe+6YJceCTsMJ1WJvayNkE52N44EAAhkfmbpmhwdcRgo0CnzAsiXdPeB1inynbnv1ornu/AlZ  
AiEA/iTqVvxeYFjaYfvi38OxfNNeqpBMiPjv3XlYzEs4vR0CIQCW/qm+3Lv9YpLlqWGipBBrHGfu  
yv4spXxiY/mkbh4ZawIhAO14JvOSqsjSHXSS/WHipFSj2H/9h1YxbUf/3AZAf0rNAiA88cTpuIZY  
G3VXJSq3Tqkh0nFQvLYipxixTdDxQVD8yQIhAIgXKKDfKeEXdmx3untvAo1zh3//MhVoo3JygBsR  
gSYn  
================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============  
原文:RSA数字签名算法  
产生签名：dxlBzv3voS7YDaaNCrUaIw7ITfHHDrdfwry9d5gSbMhKPWWfBecx0jA8jPmRuYQW2iViCDHUs3n7  
Smu3VZDuZw==  
状态：true  

四、总结

1、签名算法对非对称加密算法RSA的公钥私钥的使用是核心，配合信息摘要算法完成签名操作。其实签名看起来就是信息的摘要而已

2、密钥处理方面和非对称加密算法无异，只是将加密、解密换成签名、验证

3、RSA的数字签名算法的密钥实现与RSA加密算法一致。所以签名算法可以分为MD系列和SHA系列