windows phone 从cer中提出公钥然后再RSA加密的问题

首先.net平台SDK提供的RSA加密由于加了随机数，所以在解密的时候必须也要在.net平台解密。如果要跟java平台这样的跨平台解密就会出问题。

参考文档：http://blog.csdn.net/lubiaopan/article/details/6233517   

其中提到两种解决方案，一种是在.net平台是用BigInteger 来实现，另外一种是java端也用添加随机数的方式解决。

我下面主要写下用在.net平台用BigInteger 来实现的方式。

第一步：提取cer文件中的公钥

using (var cerStream = App.GetResourceStream(new Uri("/xxxx;component/cert.der", UriKind.Relative)).Stream)

            {

                byte[] cerBuffer = new byte[cerStream.Length];

                cerStream.Read(cerBuffer, 0, cerBuffer.Length);

                System.Security.Cryptography.X509Certificates.X509Certificate cer = new System.Security.Cryptography.X509Certificates.X509Certificate(cerBuffer);

                string publickkey = cer.GetPublicKeyString();

            }

第二步：将提取的公钥转换成能够进行RSA加密的字节流。
这里需要用到X509PublicKeyParser类，这个类windows phone SDK本身不提供,这里贴出该类的实现代码

using System;

using System.Collections.Generic;

using System.Linq;

using System.Security.Cryptography;

using System.Security.Cryptography.X509Certificates;

using System.Text;



namespace System.Security.Cryptography

{



    /// <summary>

    /// Summary description for AbstractAsn1Container.

    /// </summary>

    internal abstract class AbstractAsn1Container

    {

        private int offset;

        private byte[] data;

        private byte tag;





        internal protected AbstractAsn1Container(byte[] abyte, int i, byte tag)

        {

            this.tag = tag;

            if (abyte[i] != tag)

            {

                throw new Exception("Invalid data. The tag byte is not valid");

            }

            int length = DetermineLength(abyte, i + 1);

            int bytesInLengthField = DetermineLengthLen(abyte, i + 1);

            int start = i + bytesInLengthField + 1;

            this.offset = start + length;

            data = new byte[length];

            Array.Copy(abyte, start, data, 0, length);

        }





        internal int Offset

        {

            get

            {

                return offset;

            }

        }





        internal byte[] Bytes

        {

            get

            {

                return this.data;

            }

        }





        internal protected virtual int DetermineLengthLen(byte[] abyte0, int i)

        {

            int j = abyte0[i] & 0xff;

            switch (j)

            {

                case 129:

                    return 2;





                case 130:

                    return 3;





                case 131:

                    return 4;





                case 132:

                    return 5;





                case 128:

                default:

                    return 1;

            }

        }





        internal protected virtual int DetermineLength(byte[] abyte0, int i)

        {

            int j = abyte0[i] & 0xff;

            switch (j)

            {

                case 128:

                    return DetermineIndefiniteLength(abyte0, i);





                case 129:

                    return abyte0[i + 1] & 0xff;





                case 130:

                    int k = (abyte0[i + 1] & 0xff) << 8;

                    k |= abyte0[i + 2] & 0xff;

                    return k;





                case 131:

                    int l = (abyte0[i + 1] & 0xff) << 16;

                    l |= (abyte0[i + 2] & 0xff) << 8;

                    l |= abyte0[i + 3] & 0xff;

                    return l;

            }

            return j;

        }





        internal protected virtual int DetermineIndefiniteLength(byte[] abyte0, int i)

        {

            if ((abyte0[i - 1] & 0xff & 0x20) == 0)

                throw new Exception("Invalid indefinite length.");

            int j = 0;

            int k;

            int l;

            for (i++; abyte0[i] != 0 && abyte0[i + 1] != 0; i += 1 + k + l)

            {

                j++;

                k = DetermineLengthLen(abyte0, i + 1);

                j += k;

                l = DetermineLength(abyte0, i + 1);

                j += l;

            }





            return j;

        }









    }





    internal class IntegerContainer : AbstractAsn1Container

    {

        internal IntegerContainer(byte[] abyte, int i)

            : base(abyte, i, 0x2)

        {

        }

    }





    internal class SequenceContainer : AbstractAsn1Container

    {

        internal SequenceContainer(byte[] abyte, int i)

            : base(abyte, i, 0x30)

        {

        }

    }





    public class X509PublicKeyParser

    {

        public static RSAParameters GetRSAPublicKeyParameters(byte[] bytes)

        {

            return GetRSAPublicKeyParameters(bytes, 0);

        }





        public static RSAParameters GetRSAPublicKeyParameters(byte[] bytes, int i)

        {

            SequenceContainer seq = new SequenceContainer(bytes, i);

            IntegerContainer modContainer = new IntegerContainer(seq.Bytes, 0);

            IntegerContainer expContainer = new IntegerContainer(seq.Bytes, modContainer.Offset);

            return LoadKeyData(modContainer.Bytes, 0, modContainer.Bytes.Length, expContainer.Bytes, 0, expContainer.Bytes.Length);

        }





        public static RSAParameters GetRSAPublicKeyParameters(X509Certificate cert)

        {

            return GetRSAPublicKeyParameters(cert.GetPublicKey(), 0);

        }





        private static RSAParameters LoadKeyData(byte[] abyte0, int i, int j, byte[] abyte1, int k, int l)

        {

            byte[] modulus = null;

            byte[] publicExponent = null;

            for (; abyte0[i] == 0; i++)

                j--;





            modulus = new byte[j];

            Array.Copy(abyte0, i, modulus, 0, j);

            int i1 = modulus.Length * 8;

            int j1 = modulus[0] & 0xff;

            for (int k1 = j1 & 0x80; k1 == 0; k1 = j1 << 1 & 0xff)

                i1--;





            if (i1 < 256 || i1 > 4096)

                throw new Exception("Invalid RSA modulus size.");

            for (; abyte1[k] == 0; k++)

                l--;





            publicExponent = new byte[l];

            Array.Copy(abyte1, k, publicExponent, 0, l);

            RSAParameters p = new RSAParameters();

            p.Modulus = modulus;

            p.Exponent = publicExponent;

            return p;

        }

    }

}

然后是用X509PublicKeyParser来转换公钥

  System.Security.Cryptography.RSAParameters RSAKeyInfo;

            using (var cerStream = App.GetResourceStream(new Uri("/xxxx;component/cert.der", UriKind.Relative)).Stream)

            {

                byte[] cerBuffer = new byte[cerStream.Length];

                cerStream.Read(cerBuffer, 0, cerBuffer.Length);

                System.Security.Cryptography.X509Certificates.X509Certificate cer = new System.Security.Cryptography.X509Certificates.X509Certificate(cerBuffer);

                RSAKeyInfo = X509PublicKeyParser.GetRSAPublicKeyParameters(cer.GetPublicKey());

            }

第三步：使用BigInteger来加密数据，这里有一个BigInteger开源类库http://www.codeproject.com/Articles/2728/C-BigInteger-Class。

 BigInteger bi_e = new BigInteger(RSAKeyInfo.Exponent);

            BigInteger bi_n = new BigInteger(RSAKeyInfo.Modulus);

            BigInteger bi_data = new BigInteger(System.Text.Encoding.UTF8.GetBytes("123456789"));

            BigInteger bi_encrypted = bi_data.modPow(bi_e, bi_n);

            //rsa加密后的Base64字符串

            string rsaEncryptString = Convert.ToBase64String(bi_encrypted.getBytes());

rsaEncryptString就是加密后得到的字符串。