java与.net平台之间进行RSA加密验证

RSA加密算法虽然不分平台,标准都是一样的,但是各个平台的实现方式都不尽相同,下面来我来说说
java与.net平台之间该如何进行RSA加密验证,
java端加密-》.net端验证.net端加密-》java端验证

我对RSA算法也只是停留在应用的层面,所以我就以应用的角度来说说这个过程。
首先,我们来看一下java端的私钥和公钥的样子:
私钥:

MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAL6VJN4ZkfZA3aPPgKC3xaqT/yZT5FOlQ5TGg6heVqDVEHHVLH1E+HEEmWmuTv2ngz9pZbzy9KWkJpV59W1dgNHSSk575VjUAv0BhZXFSH0lng2mZ2Q5/2dVxKsASjJ2bQiEGUD8LO5KpaLlfQpo3ANovBZvUtHw5exegnyXyZbDAgMBAAECgYEAr7YEWr1KhLcDYg9jMUqd9QokOSspnTEGoPlx016/EeO/GKSJMynOwSyTYQszisvRxzoecdmyU7GHXVMnQ2Ds7WvbcuNkIRWmxFa4nTkk2zNF6KByvvFwLiW4LQXF6B+uV7+ZNqvfhCoD/j2wki8jfWkuuAaKnTda/axHMi+zRYECQQD73iC2GjZyur4amJQPK6d+kDlJ0dYyyUvQa0vd6mfoPnQDOIqayBaueSwWIpLI/L7eUuP9CDFryQtdBvWqD/dBAkEAwbWcrybn0eaxiPZacZLZXzXO8g12hYoXT1h0DTLvy1rnVUOspNfKZcBZMjPxT4+QEknoTShSnSbJ5sHitfZxAwJBANMlU2z2KqEh1k77jFvvb9oVVEGDbTtkL2+JE6/1W6iB+sXcd63sgb9Ai+n+j+l4oRZGjSTJ4oyGnUUemYI5IkECQQCA9JNrcv4PGYIFCOPrCfTV0m+Dan0Fp4mfE+amRsumWEz60UOktdeS53s51aSG767czgDtJLPi1MjCaz6vHnHbAkEA4NxLLg6UCAoCpXMgqqZHWMgbMwNNFr9diCWP/tZ5OJmWYHgn7zfqMXa/RNaethjdG1biIkj5h7qm6XDBBqGuxw==


公钥:

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC+lSTeGZH2QN2jz4Cgt8Wqk/8mU+RTpUOUxoOoXlag1RBx1Sx9RPhxBJlprk79p4M/aWW88vSlpCaVefVtXYDR0kpOe+VY1AL9AYWVxUh9JZ4NpmdkOf9nVcSrAEoydm0IhBlA/CzuSqWi5X0KaNwDaLwWb1LR8OXsXoJ8l8mWwwIDAQAB


我们再来看一下.net端的私钥和公钥的样子:
私钥:

<RSAKeyValue><Modulus>vpUk3hmR9kDdo8+AoLfFqpP/JlPkU6VDlMaDqF5WoNUQcdUsfUT4cQSZaa5O/aeDP2llvPL0paQmlXn1bV2A0dJKTnvlWNQC/QGFlcVIfSWeDaZnZDn/Z1XEqwBKMnZtCIQZQPws7kqlouV9CmjcA2i8Fm9S0fDl7F6CfJfJlsM=</Modulus><Exponent>AQAB</Exponent><P>+94gtho2crq+GpiUDyunfpA5SdHWMslL0GtL3epn6D50AziKmsgWrnksFiKSyPy+3lLj/Qgxa8kLXQb1qg/3QQ==</P><Q>wbWcrybn0eaxiPZacZLZXzXO8g12hYoXT1h0DTLvy1rnVUOspNfKZcBZMjPxT4+QEknoTShSnSbJ5sHitfZxAw==</Q><DP>0yVTbPYqoSHWTvuMW+9v2hVUQYNtO2Qvb4kTr/VbqIH6xdx3reyBv0CL6f6P6XihFkaNJMnijIadRR6ZgjkiQQ==</DP><DQ>gPSTa3L+DxmCBQjj6wn01dJvg2p9BaeJnxPmpkbLplhM+tFDpLXXkud7OdWkhu+u3M4A7SSz4tTIwms+rx5x2w==</DQ><InverseQ>4NxLLg6UCAoCpXMgqqZHWMgbMwNNFr9diCWP/tZ5OJmWYHgn7zfqMXa/RNaethjdG1biIkj5h7qm6XDBBqGuxw==</InverseQ><D>r7YEWr1KhLcDYg9jMUqd9QokOSspnTEGoPlx016/EeO/GKSJMynOwSyTYQszisvRxzoecdmyU7GHXVMnQ2Ds7WvbcuNkIRWmxFa4nTkk2zNF6KByvvFwLiW4LQXF6B+uV7+ZNqvfhCoD/j2wki8jfWkuuAaKnTda/axHMi+zRYE=</D></RSAKeyValue>


公钥:

<RSAKeyValue><Modulus>vpUk3hmR9kDdo8+AoLfFqpP/JlPkU6VDlMaDqF5WoNUQcdUsfUT4cQSZaa5O/aeDP2llvPL0paQmlXn1bV2A0dJKTnvlWNQC/QGFlcVIfSWeDaZnZDn/Z1XEqwBKMnZtCIQZQPws7kqlouV9CmjcA2i8Fm9S0fDl7F6CfJfJlsM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>


所以,只要将一边的公钥和私钥转换成另一边的即可。
我的做法是将java端的公钥和私钥转换成.net端的公钥和私钥。

咱们先看私钥的转换:

// --- Returns XML encoded RSA private key string suitable for .NET
    // CryptoServiceProvider.FromXmlString(true) ------
    // --- Leading zero bytes (most significant) must be removed for XML
    // encoding for .NET; otherwise format error ---

    private String getRSAPrivateKeyAsNetFormat(byte[] encodedPrivkey) {
        try {
            StringBuffer buff = new StringBuffer(1024);

            PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(
                    encodedPrivkey);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory
                    .generatePrivate(pvkKeySpec);

            buff.append("<RSAKeyValue>");
            buff.append("<Modulus>"
                    + b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");

            buff.append("<Exponent>"
                    + b64encode(removeMSZero(pvkKey.getPublicExponent()
                            .toByteArray())) + "</Exponent>");

            buff.append("<P>"
                    + b64encode(removeMSZero(pvkKey.getPrimeP().toByteArray()))
                    + "</P>");

            buff.append("<Q>"
                    + b64encode(removeMSZero(pvkKey.getPrimeQ().toByteArray()))
                    + "</Q>");

            buff.append("<DP>"
                    + b64encode(removeMSZero(pvkKey.getPrimeExponentP()
                            .toByteArray())) + "</DP>");

            buff.append("<DQ>"
                    + b64encode(removeMSZero(pvkKey.getPrimeExponentQ()
                            .toByteArray())) + "</DQ>");

            buff.append("<InverseQ>"
                    + b64encode(removeMSZero(pvkKey.getCrtCoefficient()
                            .toByteArray())) + "</InverseQ>");

            buff.append("<D>"
                    + b64encode(removeMSZero(pvkKey.getPrivateExponent()
                            .toByteArray())) + "</D>");
            buff.append("</RSAKeyValue>");

            return buff.toString().replaceAll("[ \t\n\r]", "");
        } catch (Exception e) {
            System.err.println(e);
            return null;
        }
    }


再看公钥的转换:

// --- Returns XML encoded RSA public key string suitable for .NET
    // CryptoServiceProvider.FromXmlString(true) ------
    // --- Leading zero bytes (most significant) must be removed for XML
    // encoding for .NET; otherwise format error ---

    private String getRSAPublicKeyAsNetFormat(byte[] encodedPrivkey) {
        try {
            StringBuffer buff = new StringBuffer(1024);

            PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(
                    encodedPrivkey);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory
                    .generatePrivate(pvkKeySpec);
            buff.append("<RSAKeyValue>");
            buff.append("<Modulus>"
                    + b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");
            buff.append("<Exponent>"
                    + b64encode(removeMSZero(pvkKey.getPublicExponent()
                            .toByteArray())) + "</Exponent>");
            buff.append("</RSAKeyValue>");
            return buff.toString().replaceAll("[ \t\n\r]", "");
        } catch (Exception e) {
            System.err.println(e);
            return null;
        }
    }


通过以上两个方法,就可以将java端的公钥和私钥转换为.net端的了。
然后.net端可以用如下代码装载转换好的key

 //java端转换为.net端的私钥 
                string NET_PRIVATE_KEY = @"<RSAKeyValue><Modulus>lKc3QnhdBGrA+Tkz0QvbgEWHDjS/AMp4bhwqFgQXdo+mIwC/8POr8GpgCpsY2GgU+PBIFI51q2U64aKFwQYQhxSiQI3r7kAa5+DVQVhheRlAaHz/iRMr2HqVkxqtjoTbNjVCMuTqgX7xu30YDcX9ZXSH0lGWCy3NEdzxBpOAtFk=</Modulus><Exponent>AQAB</Exponent><P>3eX5uQZalJF/tgosNUUV8ss4aVAwDntID63Ta6bFEnZFzp3YckXKGzmOQuygHK0tuUviN+BQFlk0eelMz3JMiQ==</P><Q>q3+YtH0B30ijTITtGWqNI+zXbhpodhVuugWHkihz9XKFQ7srbYA3YovvyOmK1Q/zlF92X3MFfUjRFWB/fEVVUQ==</Q><DP>Ey1tB7Ck43Ivt2vppjDyVKl7lp53iMje0XwUaZlgLthJ8DF0I2wkq3Wt9dq9e7z71qfYRTv9r/DFuEORf9xBAQ==</DP><DQ>n2ynDSmkIugIfeqX6meluv7BqWW9NABqhVz8kT8vxLzn63XEQi/NzLtfdbq8x6HjgktX5BUtxjB5xVCGUoS1cQ==</DQ><InverseQ>FNZDF90zR/2b/kevm4DomVTs7Iz/oaidOFsLQqD4BZfycuMdpTMAO8UUVtK5+eL7G24JaJAmb1U6QfkTc4syOQ==</InverseQ><D>cVf2aHZB5kZHkT+uZKx31xwsWAabxEyc+sf6xwKjqUDqWjIOJ/iDlzJkvHF5xjfGFfGP5CyjR+ZNuREkjwLCwjBiOhp34QMuN22LbKfHsvgHYiAOqkTxwASQ2FwaonA8nrfluHZhWECMrOSYag2QWuaOoToF91XvkNf8tBFcHQE=</D></RSAKeyValue>";
                //java端转换为.net端的公钥     
                //string NET_PUBLIC_KEY = @"<RSAKeyValue><Modulus>vpUk3hmR9kDdo8+AoLfFqpP/JlPkU6VDlMaDqF5WoNUQcdUsfUT4cQSZaa5O/aeDP2llvPL0paQmlXn1bV2A0dJKTnvlWNQC/QGFlcVIfSWeDaZnZDn/Z1XEqwBKMnZtCIQZQPws7kqlouV9CmjcA2i8Fm9S0fDl7F6CfJfJlsM=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
                RSA = new RSACryptoServiceProvider();
                RSA.FromXmlString(NET_PRIVATE_KEY);
               //RSA.FromXmlString(NET_PUBLIC_KEY);



注意,如果.net端只是验证,可以只导入NET_PUBLIC_KEY;如果.net端既加密又验证,那么只导入NET_PRIVATE_KEY即可,不用导入NET_PUBLIC_KEY。

下面给出完整代码及使用说明:
使用说明:
1.使用java端的GenerateKeys方法,生成java端和.net端需要的公钥和私钥
2.java端调用Sign方法进行加密,调用Verify方法进行验证
3..net端调用signData方法进行加密,调用verifySignature方法进行验证

.net端c#代码:

using System;
using System.Security.Cryptography;
using System.IO;
using System.Text;
using System.Xml;
using System.Web;
namespace RSASecurity
{
    class ssosign
    {
        private RSAParameters RSAKeyInfo;
        private static RSACryptoServiceProvider RSA=null;
        //私钥
        private const string NET_PRIVATE_KEY = @"<RSAKeyValue><Modulus>lKc3QnhdBGrA+Tkz0QvbgEWHDjS/AMp4bhwqFgQXdo+mIwC/8POr8GpgCpsY2GgU+PBIFI51q2U64aKFwQYQhxSiQI3r7kAa5+DVQVhheRlAaHz/iRMr2HqVkxqtjoTbNjVCMuTqgX7xu30YDcX9ZXSH0lGWCy3NEdzxBpOAtFk=</Modulus><Exponent>AQAB</Exponent><P>3eX5uQZalJF/tgosNUUV8ss4aVAwDntID63Ta6bFEnZFzp3YckXKGzmOQuygHK0tuUviN+BQFlk0eelMz3JMiQ==</P><Q>q3+YtH0B30ijTITtGWqNI+zXbhpodhVuugWHkihz9XKFQ7srbYA3YovvyOmK1Q/zlF92X3MFfUjRFWB/fEVVUQ==</Q><DP>Ey1tB7Ck43Ivt2vppjDyVKl7lp53iMje0XwUaZlgLthJ8DF0I2wkq3Wt9dq9e7z71qfYRTv9r/DFuEORf9xBAQ==</DP><DQ>n2ynDSmkIugIfeqX6meluv7BqWW9NABqhVz8kT8vxLzn63XEQi/NzLtfdbq8x6HjgktX5BUtxjB5xVCGUoS1cQ==</DQ><InverseQ>FNZDF90zR/2b/kevm4DomVTs7Iz/oaidOFsLQqD4BZfycuMdpTMAO8UUVtK5+eL7G24JaJAmb1U6QfkTc4syOQ==</InverseQ><D>cVf2aHZB5kZHkT+uZKx31xwsWAabxEyc+sf6xwKjqUDqWjIOJ/iDlzJkvHF5xjfGFfGP5CyjR+ZNuREkjwLCwjBiOhp34QMuN22LbKfHsvgHYiAOqkTxwASQ2FwaonA8nrfluHZhWECMrOSYag2QWuaOoToF91XvkNf8tBFcHQE=</D></RSAKeyValue>";
        //公钥参数
        private const string PUB_KEY_MODULES = @"1lpnLvumD8/NedJ7s4WS8UO9OORbXVTgJXmfa72bI4A1L1l6Np91BETQ+yB8Fq6iGWw5OR8OB2UbRBcopb2etepDqWd7kmCtbVT36kTW+E8dWdaVjbI2BCXEGaXuzPPdGOlp52OaawYR5zyG0MiCvJ4jE7RDJax4Cl24ZqPUs4U=";
        //公钥参数
        private const string PUB_KEY_EXP = @"AQAB";
        /// <summary>
        /// Reads the Public key file and Loads the RSAParameters with the 
        /// Modulous and Exponent data.
        /// </summary>
        public ssosign(RSAType type)
        {
            
            RSA = new RSACryptoServiceProvider();
            //if (type == RSAType.ITDMS)
            //{
            //    RSAKeyInfo = new RSAParameters();
            //    RSAKeyInfo.Modulus = Convert.FromBase64String(PUB_KEY_MODULES);
            //    RSAKeyInfo.Exponent = Convert.FromBase64String(PUB_KEY_EXP);
            //    RSA.ImportParameters(RSAKeyInfo);
            //}
            //else //type == RSAType.RSP
            //{ 
                RSA.FromXmlString(NET_PRIVATE_KEY);
            //}
        }
        /// <summary>
        /// sign the data
        /// </summary>
        /// <param name="dataToBeSigned"></param>
        /// <returns></returns>
        public string signData(string dataToBeSigned)
        {
            byte[] data = Encoding.UTF8.GetBytes(dataToBeSigned);

            byte[] endata = RSA.SignData(data,"SHA1");

            return Convert.ToBase64String(endata);
           
        }
        /// <summary>
        /// Verifies the signature for a given data.
        /// </summary>
        /// <param name="signature">Signature data in Base64</param>
        /// <param name="signedData">Original data in BASE64</param>
        /// <returns>True if signature is valid else False</returns>
        public bool verifySignature(string signature,string signedData)
        {
            byte[] sign = Convert.FromBase64String(signature);
            return verifySignature(sign,signedData);
        }
        /// <summary>
        /// Verifies the signature for a given data.
        /// </summary>
        /// <param name="signature">The signature </param>
        /// <param name="signedData">Original data in Base64</param>
        /// <returns></returns>
        public bool verifySignature(byte[] signature , string signedData)
        {
            try
            {
                byte[] hash = Convert.FromBase64String(signedData);
                if(RSA.VerifyData(hash,"SHA1",signature))
                {
                    return true;
                }
                else
                {
                    //Console.WriteLine("The signature is not valid.");
                    return false;
                }
            }
            catch(Exception e)    
            {
                Console.WriteLine(e.Message);
                return false;
            }
        }

        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            ssosign sso = new ssosign(RSAType.RSP);
            string user = "limt";
            string time = "2010-12-01 11:00:00";
            string data = user + time;
            string endata = Convert.ToBase64String(Encoding.UTF8.GetBytes(data));
            //string ensignature = @"SjAoGfsw+vjTLOEC7eXq+V41Q6UNdRXVIdD+5gTbEfy8tfE8cgDIZRn4uIAydYfqprhJ2GbJnTTpQZxOJ0PsQR9TUVVGp0QmbNOJc/Zjm0kuBBwF43ESTSMe0CpXqOLMpLasP7hEdJlVgcrEIXijde0GxSD7qZ+6Ty8P0istR1Y=";
            string ensignature = sso.signData(data);

            bool result = sso.verifySignature(ensignature, endata);

            Console.WriteLine("Data is validate: " + result);
            //string str = HttpUtility.UrlDecode("MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OQ%3D%3D",Encoding.UTF8);
            //Console.WriteLine(str);
            Console.ReadLine();
        }
    }
}


java端代码:

package rsa;

import java.security.*;
import java.security.spec.*;
import java.io.*;
import java.security.interfaces.*;

import org.castor.util.Base64Decoder;
import org.castor.util.Base64Encoder;


public class ssosign {

    private KeyPairGenerator keyGen; // Key pair generator for RSA
    private PrivateKey privateKey; // Private Key Class
    private PublicKey publicKey; // Public Key Class
    private KeyPair keypair; // KeyPair Class
    private Signature sign; // Signature, used to sign the data

    /**
     * Default Constructor. Instantiates the signature algorithm.
     */
    public ssosign() {
        try {
            // Get the instance of Signature Engine.
            sign = Signature.getInstance("SHA1withRSA");
        } catch (NoSuchAlgorithmException nsa) {
            System.out.println("" + nsa.getMessage());
        }
    }

    /**
     * Signs the data and return the signature for a given data.
     * 
     * @param user
     *            The current user’s external person number
     * @param time
     *            The current time in string format: yyyy-mm-dd hh:mm:ss
     * @param EncodedCert
     *            The hard coded certificate string, i.e. <b>private key</b>
     * @return String URLEncode string of Signature
     * @throws UnsupportedEncodingException
     */
    public String Sign(String user, String time, String EncodedCert) {

        String returnStr = "";
        try {
            String toBeSigned = user + time;
            byte[] signature = signData(toBeSigned.getBytes(), EncodedCert);
            String base64Signature = b64encode(signature);
            returnStr = base64Signature;// java.net.URLEncoder.encode(base64Signature,
                                        // "UTF-8");
        }
        // catch (UnsupportedEncodingException ue) {
        // // TODO Auto-generated catch block
        // System.out.println(ue.getMessage());
        // }
        catch (Exception e) {
            System.out.println(e);
        }
        return returnStr;
    }

    public boolean Verify(String base64signature, String user, String time,
            String EncodedCert) {
        String toBeSigned = user + time;
        // try {
        // base64signature = java.net.URLDecoder.decode(base64signature,
        // "UTF-8");
        // } catch (UnsupportedEncodingException e) {
        // // TODO Auto-generated catch block
        // e.printStackTrace();
        // }
        byte[] signature = b64decode(base64signature);
        return verifySignature(signature, toBeSigned.getBytes(), EncodedCert);
    }

    /**
     * Generates the keys for given size.
     * 
     * @param size
     *            Key Size [512|1024]
     * @param privateKeyPath
     *            Private key will be generated in file which can be named with
     *            "privateKeyPath" parameter;
     * @param publicKeyPath
     *            Public key will be generated in file which can be named with
     *            "publicKeyPath" parameter;
     * @param netPublicKeyPath
     *            Public key can be read for .Net platform will be generated in
     *            file which can be named with "netPublicKeyPath" parameter;
     */
    public void GenerateKeys(int size, String privateKeyPath,
            String publicKeyPath, String netPublicKeyPath,
            String netPrivateKeyPath) {
        try {
            System.out.println("Generatign Keys");
            // Get Key Pair Generator for RSA.
            keyGen = KeyPairGenerator.getInstance("RSA");
            keyGen.initialize(size);
            keypair = keyGen.genKeyPair();
            privateKey = keypair.getPrivate();
            publicKey = keypair.getPublic();

            // Get the bytes of the public and private keys
            byte[] privateKeyBytes = privateKey.getEncoded();
            byte[] publicKeyBytes = publicKey.getEncoded();

            // write bytes to corresponding files.
            writeKeyBytesToFile(b64encode(privateKeyBytes).getBytes(),
                    privateKeyPath);
            String encodedValue = b64encode(publicKeyBytes);
            writeKeyBytesToFile(encodedValue.getBytes(), publicKeyPath);

            // Generate the Private Key, Public Key and Public Key in XML
            // format.
            PrivateKey privateKey = KeyFactory.getInstance("RSA")
                    .generatePrivate(new PKCS8EncodedKeySpec(privateKeyBytes));
            PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(
                    new X509EncodedKeySpec(publicKeyBytes));
            // RSAPublicKey rsaPublicKey = (RSAPublicKey)
            // KeyFactory.getInstance(
            // "RSA").generatePublic(
            // new X509EncodedKeySpec(publicKeyBytes));
            // // get the modules and exponent of public key to make compatible
            // // .Net public key file
            // String netPublicKey = getRSAPublicKeyAsNetFormat(rsaPublicKey);
            // Store the modules and exponent (Generated .Net public key file)
            // in file
            // writeKeyBytesToFile(netPublicKey.getBytes(), netPublicKeyPath);

            String netPrivateKey = getRSAPrivateKeyAsNetFormat(privateKeyBytes);
            writeKeyBytesToFile(netPrivateKey.getBytes(), netPrivateKeyPath);

            String netPublicKey = getRSAPublicKeyAsNetFormat(privateKeyBytes);
            writeKeyBytesToFile(netPublicKey.getBytes(), netPublicKeyPath);

        } catch (java.security.NoSuchAlgorithmException e) {
            System.out
                    .println("No such algorithm. Please check the JDK version."
                            + e.getCause());
        } catch (java.security.spec.InvalidKeySpecException ik) {
            System.out.println("Invalid Key Specs. Not valid Key files."
                    + ik.getCause());
        } catch (UnsupportedEncodingException ex) {
            System.out.println(ex);
        } catch (IOException ioe) {
            System.out.println("Files not found on specified path. "
                    + ioe.getCause());
        } catch (Exception ex1) {
            System.out.println(ex1);
        }

    }

    /**
     * Initialize only the private key.
     */
    private void initializePrivateKey(String privateKeyStr) {
        try {
            // Read key files back and decode them from BASE64
            byte[] privateKeyBytes = b64decode(privateKeyStr);

            // Convert back to public and private key objects
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
                    privateKeyBytes);
            privateKey = keyFactory.generatePrivate(privateKeySpec);
        } catch (InvalidKeySpecException e) {
            System.out.println("Invalid Key Specs. Not valid Key files."
                    + e.getCause());
        } catch (NoSuchAlgorithmException e) {
            System.out
                    .println("There is no such algorithm. Please check the JDK ver."
                            + e.getCause());
        }
    }

    /**
     * Signs the data and return the signature for a given data.
     * 
     * @param toBeSigned
     *            Data to be signed
     * @return byte[] Signature
     */
    private byte[] signData(byte[] toBeSigned, String EncodedCert) {
        if (privateKey == null) {
            initializePrivateKey(EncodedCert);
        }
        try {
            Signature rsa = Signature.getInstance("SHA1withRSA");
            rsa.initSign(privateKey);
            rsa.update(toBeSigned);
            return rsa.sign();
        } catch (NoSuchAlgorithmException ex) {
            System.out.println(ex);
        } catch (InvalidKeyException in) {
            System.out
                    .println("Invalid Key file.Please check the key file path"
                            + in.getCause());
        } catch (SignatureException se) {
            System.out.println(se);
        }
        return null;
    }

    /**
     * Verifies the signature for the given bytes using the public key.
     * 
     * @param signature
     *            Signature
     * @param data
     *            Data that was signed
     * @param EncodedCert
     *            public key string
     * @return boolean True if valid signature else false
     */
    private boolean verifySignature(byte[] signature, byte[] data,
            String EncodedCert) {
        try {
            initializePublicKey(EncodedCert);
            sign.initVerify(publicKey);
            sign.update(data);
            return sign.verify(signature);
        } catch (SignatureException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
        }

        return false;
    }

    /**
     * Initializes the public and private keys.
     */
    private void initializePublicKey(String publicKeyStr) {
        try {
            // Read key files back and decode them from BASE64
            byte[] publicKeyBytes = b64decode(publicKeyStr);

            // Convert back to public and private key objects
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");

            EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
                    publicKeyBytes);
            publicKey = keyFactory.generatePublic(publicKeySpec);

        } catch (InvalidKeySpecException e) {
            System.out.println("Invalid Key Specs. Not valid Key files."
                    + e.getCause());
        } catch (NoSuchAlgorithmException e) {
            System.out
                    .println("There is no such algorithm. Please check the JDK ver."
                            + e.getCause());
        }
    }

//    /**
//     * Gets the RSA Public Key. The key idea is to make the key readable for
//     * .Net platform.
//     * 
//     * @param key
//     *            RSAPublicKey
//     * @return String the public key that .Net platform can read
//     */
//    private String getRSAPublicKeyAsNetFormat(RSAPublicKey key) {
//
//        byte[] modulusBytes = key.getModulus().toByteArray();
//        modulusBytes = stripLeadingZeros(modulusBytes);
//        String modules = b64encode(modulusBytes);
//
//        byte[] exponentBytes = key.getPublicExponent().toByteArray();
//        String exponent = b64encode(exponentBytes);
//
//        String result = "modules : " + modules + "\r\n" + "exponent : "
//                + exponent;
//        return result;
//    }

    /**
     * Utility method to delete the leading zeros from the modulus.
     * 
     * @param a
     *            modulus
     * @return modulus
     */
    private byte[] stripLeadingZeros(byte[] a) {
        int lastZero = -1;
        for (int i = 0; i < a.length; i++) {
            if (a[i] == 0) {
                lastZero = i;
            } else {
                break;
            }
        }
        lastZero++;
        byte[] result = new byte[a.length - lastZero];
        System.arraycopy(a, lastZero, result, 0, result.length);
        return result;
    }

    /**
     * Writes the bytes of the key in a file.
     * 
     * @param key
     *            byte array of key data.
     * @param file
     *            File Name
     */
    private void writeKeyBytesToFile(byte[] key, String file)
            throws IOException {
        OutputStream out = new FileOutputStream(file);
        out.write(key);
        out.close();
    }

    // --- Returns XML encoded RSA private key string suitable for .NET
    // CryptoServiceProvider.FromXmlString(true) ------
    // --- Leading zero bytes (most significant) must be removed for XML
    // encoding for .NET; otherwise format error ---

    private String getRSAPrivateKeyAsNetFormat(byte[] encodedPrivkey) {
        try {
            StringBuffer buff = new StringBuffer(1024);

            PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(
                    encodedPrivkey);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory
                    .generatePrivate(pvkKeySpec);

            buff.append("<RSAKeyValue>");
            buff.append("<Modulus>"
                    + b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");

            buff.append("<Exponent>"
                    + b64encode(removeMSZero(pvkKey.getPublicExponent()
                            .toByteArray())) + "</Exponent>");

            buff.append("<P>"
                    + b64encode(removeMSZero(pvkKey.getPrimeP().toByteArray()))
                    + "</P>");

            buff.append("<Q>"
                    + b64encode(removeMSZero(pvkKey.getPrimeQ().toByteArray()))
                    + "</Q>");

            buff.append("<DP>"
                    + b64encode(removeMSZero(pvkKey.getPrimeExponentP()
                            .toByteArray())) + "</DP>");

            buff.append("<DQ>"
                    + b64encode(removeMSZero(pvkKey.getPrimeExponentQ()
                            .toByteArray())) + "</DQ>");

            buff.append("<InverseQ>"
                    + b64encode(removeMSZero(pvkKey.getCrtCoefficient()
                            .toByteArray())) + "</InverseQ>");

            buff.append("<D>"
                    + b64encode(removeMSZero(pvkKey.getPrivateExponent()
                            .toByteArray())) + "</D>");
            buff.append("</RSAKeyValue>");

            return buff.toString().replaceAll("[ \t\n\r]", "");
        } catch (Exception e) {
            System.err.println(e);
            return null;
        }
    }

    // --- Returns XML encoded RSA public key string suitable for .NET
    // CryptoServiceProvider.FromXmlString(true) ------
    // --- Leading zero bytes (most significant) must be removed for XML
    // encoding for .NET; otherwise format error ---

    private String getRSAPublicKeyAsNetFormat(byte[] encodedPrivkey) {
        try {
            StringBuffer buff = new StringBuffer(1024);

            PKCS8EncodedKeySpec pvkKeySpec = new PKCS8EncodedKeySpec(
                    encodedPrivkey);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            RSAPrivateCrtKey pvkKey = (RSAPrivateCrtKey) keyFactory
                    .generatePrivate(pvkKeySpec);
            buff.append("<RSAKeyValue>");
            buff.append("<Modulus>"
                    + b64encode(removeMSZero(pvkKey.getModulus().toByteArray()))
                    + "</Modulus>");
            buff.append("<Exponent>"
                    + b64encode(removeMSZero(pvkKey.getPublicExponent()
                            .toByteArray())) + "</Exponent>");
            buff.append("</RSAKeyValue>");
            return buff.toString().replaceAll("[ \t\n\r]", "");
        } catch (Exception e) {
            System.err.println(e);
            return null;
        }
    }

    // --------- remove leading (Most Significant) zero byte if present
    // ----------------
    private byte[] removeMSZero(byte[] data) {
        byte[] data1;
        int len = data.length;
        if (data[0] == 0) {
            data1 = new byte[data.length - 1];
            System.arraycopy(data, 1, data1, 0, len - 1);
        } else
            data1 = data;

        return data1;
    }

    private String b64encode(byte[] data) {

        String b64str = new String(Base64Encoder.encode(data));
        return b64str;
    }

    private byte[] b64decode(String data) {
        byte[] decodeData = Base64Decoder.decode(data);
        return decodeData;
    }

    public static void main(String args[]) {
        ssosign sso = new ssosign();
//         sso.GenerateKeys(
//         1024,
//         "d:/private.key",
//         "d:/public.key",
//         "d:/netpublic.key",
//         "d:/netprivate.key");

         String signedData = sso
         .Sign("zhangxn",
         "2010-12-10 11:21:18",
         "MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBAL6VJN4ZkfZA3aPPgKC3xaqT/yZT5FOlQ5TGg6heVqDVEHHVLH1E+HEEmWmuTv2ngz9pZbzy9KWkJpV59W1dgNHSSk575VjUAv0BhZXFSH0lng2mZ2Q5/2dVxKsASjJ2bQiEGUD8LO5KpaLlfQpo3ANovBZvUtHw5exegnyXyZbDAgMBAAECgYEAr7YEWr1KhLcDYg9jMUqd9QokOSspnTEGoPlx016/EeO/GKSJMynOwSyTYQszisvRxzoecdmyU7GHXVMnQ2Ds7WvbcuNkIRWmxFa4nTkk2zNF6KByvvFwLiW4LQXF6B+uV7+ZNqvfhCoD/j2wki8jfWkuuAaKnTda/axHMi+zRYECQQD73iC2GjZyur4amJQPK6d+kDlJ0dYyyUvQa0vd6mfoPnQDOIqayBaueSwWIpLI/L7eUuP9CDFryQtdBvWqD/dBAkEAwbWcrybn0eaxiPZacZLZXzXO8g12hYoXT1h0DTLvy1rnVUOspNfKZcBZMjPxT4+QEknoTShSnSbJ5sHitfZxAwJBANMlU2z2KqEh1k77jFvvb9oVVEGDbTtkL2+JE6/1W6iB+sXcd63sgb9Ai+n+j+l4oRZGjSTJ4oyGnUUemYI5IkECQQCA9JNrcv4PGYIFCOPrCfTV0m+Dan0Fp4mfE+amRsumWEz60UOktdeS53s51aSG767czgDtJLPi1MjCaz6vHnHbAkEA4NxLLg6UCAoCpXMgqqZHWMgbMwNNFr9diCWP/tZ5OJmWYHgn7zfqMXa/RNaethjdG1biIkj5h7qm6XDBBqGuxw==");
         System.out.println(signedData);

//        String signedData = "D+vkrMIe9cJyr3kELI5jNes/bJe7MLExyJDMqJyBlVgFtmPNQ723IsBtWmqO93yoBoKHaxeTI1kwaJzESe3X5vqS6TfFBTl+IeX5aJ/cc1+Hxo5Rr2QZwzUywgS/e3gRC+Ik+Fx0M0gBaQTGNdIDNaIvl776+0SNVaD0L3Sar9k=";
//        boolean res = sso
//                .Verify(signedData,
//                        "zhangxn",
//                        "2010-12-10 11:21:18",
//                        "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDWWmcu+6YPz8150nuzhZLxQ7045FtdVOAleZ9rvZsjgDUvWXo2n3UERND7IHwWrqIZbDk5Hw4HZRtEFyilvZ616kOpZ3uSYK1tVPfqRNb4Tx1Z1pWNsjYEJcQZpe7M890Y6WnnY5prBhHnPIbQyIK8niMTtEMlrHgKXbhmo9SzhQIDAQAB");
//        System.out.println(res);

    }

 

转载于:https://www.cnblogs.com/amylis_chen/p/8611838.html

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/466376.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

渡虎谷告诉你CSS的结构和规则

基本语法规则选择符任何HTML元素都可以是一个CSS1的选择符。选择符仅仅是指向特别样式的元素。例如&#xff0c; P { text-indent: 3em }当中的选择符是P。 类选择符单一个选择符能有不同的CLASS(类)&#xff0c;因而允许同一元素有不同样式。例如&#xff0c;一个网页制作者也…

阿莫电子为啥越来越差?

我是在上大学接触到这个论坛的&#xff0c;当时我们创新基地的学长们都注册了这个论坛的账号。记得有一次看见我旁边的学长在浏览一个技术论坛&#xff0c;我就问「这个是什么网站&#xff0c;看起来好牛逼的样子」。我记得他说了一句「阿莫电子你都不知道&#xff0c;你是不是…

TQ210——文件系统

TQ210——文件系统 1.busybox 致命错误: curses.h:没有那个文件或目录 解决办法:ubuntu系统中缺少一个套件 ncurses devel,把此套件安装下即可 $ sudo apt-get install libncurses5-dev 2.Linux 根文件系统目录结构 (1) /bin 目录 该目录下存放所有用户(包括系统管理员和一…

六自由度正反解算法

https://wenku.baidu.com/view/474595887e21af45b307a8e6.html https://wenku.baidu.com/view/8dc7d91d6d85ec3a87c24028915f804d2a168756.html https://max.book118.com/html/2017/0701/119416936.shtm

stdout字符串过滤输出

功能 把stdout的内容重定向到一个文件,然后从文件里面读取数据,再把数据对应的字符串给过滤掉,重新输出到stdout中 代码 // gcc xx.c -lpthread && ./a.out #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <fcntl.h&…

使用栈实现中缀表达式转为后缀表达式和后缀表达式的求解

书籍在线网址http://interactivepython.org/runestone/static/pythonds/index.html 中文翻译书籍&#xff1a;https://facert.gitbooks.io/python-data-structure-cn/ 将中缀表达式转换为后缀表达式 中缀表达式&#xff08;上图&#xff0c;一般书写&#xff09;转换为后缀表达…

C#基础:Lambda表达式

从委托的角度来看&#xff0c;Lambda表达式与匿名方法没有区别。在【C#基础&#xff1a;匿名方法】一文中&#xff0c;我使用了匿名方法来调用List<T>的FindAll方法。从C# 3.0开始&#xff0c;在使用匿名方法的地方&#xff0c;完全可以用Lambda表达式来代替。Lambda表达…

TQ210 —— 点亮LED

TQ210 —— 点亮LED 1、S5PV210 GPIO硬件简介 1.1、GPIO 【S5PV210有237个多功能IO口&#xff0c;通过设置寄存器确定某个引脚用于输入输出或者其他特殊功能】 GPIO的英文全称为General-PurposeIO ports&#xff0c;也就是通用IO接口。在嵌入式系统中常常有数量众多&#xff0…

bind1nd\bind2nd

https://www.cnblogs.com/renyuan/p/6216375.html https://blog.csdn.net/jnu_simba/article/details/9530341

拆解镍氢电池充电器,简单的电路设计令人震惊!

上班爱摸鱼&#xff0c;下班爱钓鱼&#xff0c;于是买了一个钓鱼机。不贵&#xff0c;几十块钱&#xff0c;带4条鱼竿。长这样&#xff1a;电池驱动&#xff0c;钓起鱼来乐趣无穷&#xff1a;惊喜的是&#xff0c;钓鱼机自带附赠的电池是可充电的&#xff0c;省下不少买干电池的…

设备底座几个常见固定方式

在运营商我们可以经常发现如下的固定方式&#xff0c;因为设备厂家的不同&#xff0c;以及机房上下走线方式&#xff0c;固定方式也有些差异。可以清楚看见&#xff0c;底座可以靠螺母进行微调使机柜高度&#xff0c;底部还有膨胀螺丝打入地板还有很多机柜是不加微调用的底座&a…

抽35块树莓派新品单片机送给可爱的你们

我是谁~公众号「嵌入式Linux」&#xff0c;深入解析简明扼要直白解释各种技术问题&#xff0c;包括但不局限于Linux、单片机、半导体、Android、C语言等等。号主从事嵌入式软件行业有10余年&#xff0c;建立了10余个技术微信群&#xff0c;整理了很多技术资料&#xff0c;欢迎大…

bitset类

C语言的一个类库&#xff0c;用来方便地管理一系列的bit位而不用程序员自己来写代码。 bitset除了可以访问指定下标的bit位以外&#xff0c;还可以把它们作为一个整数来进行某些统计。 可以如下声明一个该类型变量&#xff1a; bitsetvarm (M) 其中varm为变量名。 N表示该类型在…

TQ210——时钟系统

TQ210——时钟系统 1、时钟域 一般来讲&#xff0c; MCU 的主时钟来源主要是外部晶振或外部时钟&#xff0c;比较常见的是 外 部晶振。一般情况&#xff0c;系统内所使用的时钟都是高频率的时钟&#xff0c;外部晶振一般达不到那么高的频率&#xff0c;所以一般使用锁相环电路&…

Android 监听耳机的插拔事件

一般采用的是动态监听的方式来实现的&#xff1a; package com.renhui.ej;import android.content.BroadcastReceiver; import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.os.Bundle; import android.supp…

ubuntu操作

下面的命令大都需要在控制台 / 终端 / shell 下输入。 控制台, 终端, 和 shell 意味着同样一件事 - 一个命令行界面&#xff0c; 他可以用来控 制系统。 打开一个控制台: 应用程序 --> 附件 --> 终端 任何一个使用 sudo 作为前缀的命令都需要拥有管理员 (或 root) 访问权…

我的文章汇总

2018年文章汇总2019年文章汇总2020年文章汇总专辑|Linux文章汇总专辑|程序人生专辑|C语言专辑|Git专辑|安卓系统专辑|嵌入式我的知识小密圈关注公众号&#xff0c;后台回复「1024」获取学习资料网盘链接。欢迎点赞&#xff0c;关注&#xff0c;转发&#xff0c;在看&#xff0c…

CMap

https://blog.csdn.net/u010879420/article/details/53914767

webpack-安装

以前配置的gulpfile.js&#xff0c;随着版本的迭代更新&#xff0c;现在已经... 1.安装webpack npm i -g webpack-cli && npm i -g babel-preset-env 2.弹射出窗口&#xff08;我们未安装Git&#xff0c;或者未找到Git path&#xff0c;请配置path&#xff09; 3.再次执…

TQ210——S5PV210中断体系

TQ210——S5PV210中断体系 中断是指 CPU 在执行程序的过程中&#xff0c;遇到异常情况需要处理&#xff0c; CPU停 止当前程序的运行&#xff0c;保存当前程序运行处的必要参数&#xff0c;转去处理这些异常情况&#xff0c; 处理结束后再返回当前程序的间断处&#xff0c;继续…