DotNetUtilities.cs :  » PDF » iTextSharp » Org » BouncyCastle » Security » C# / CSharp Open Source

#if !NETCF_1_0

using System;
using System.Security.Cryptography;
using SystemX509System.Security.Cryptography.X509Certificates;

using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.X509;

namespace Org.BouncyCastle.Security{
  /// <summary>
  /// A class containing methods to interface the BouncyCastle world to the .NET Crypto world.
  /// </summary>
  public sealed class DotNetUtilities
  {
    private DotNetUtilities()
    {
    }

    /// <summary>
    /// Create an System.Security.Cryptography.X509Certificate from an X509Certificate Structure.
    /// </summary>
    /// <param name="x509Struct"></param>
    /// <returns>A System.Security.Cryptography.X509Certificate.</returns>
    public static SystemX509.X509Certificate ToX509Certificate(
      X509CertificateStructure x509Struct)
    {
      return new SystemX509.X509Certificate(x509Struct.GetDerEncoded());
    }

    public static SystemX509.X509Certificate ToX509Certificate(
      X509Certificate x509Cert)
    {
      return new SystemX509.X509Certificate(x509Cert.GetEncoded());
    }

    public static X509Certificate FromX509Certificate(
      SystemX509.X509Certificate x509Cert)
    {
      return new X509CertificateParser().ReadCertificate(x509Cert.GetRawCertData());
    }

    public static AsymmetricCipherKeyPair GetDsaKeyPair(
      DSA dsa)
    {
      return GetDsaKeyPair(dsa.ExportParameters(true));
    }

    public static AsymmetricCipherKeyPair GetDsaKeyPair(
      DSAParameters dp)
    {
      DsaValidationParameters validationParameters = (dp.Seed != null)
        ?  new DsaValidationParameters(dp.Seed, dp.Counter)
        :  null;

      DsaParameters parameters = new DsaParameters(
        new BigInteger(1, dp.P),
        new BigInteger(1, dp.Q),
        new BigInteger(1, dp.G),
        validationParameters);

      DsaPublicKeyParameters pubKey = new DsaPublicKeyParameters(
        new BigInteger(1, dp.Y),
        parameters);

      DsaPrivateKeyParameters privKey = new DsaPrivateKeyParameters(
        new BigInteger(1, dp.X),
        parameters);

      return new AsymmetricCipherKeyPair(pubKey, privKey);
    }

    public static DsaPublicKeyParameters GetDsaPublicKey(
      DSA dsa)
    {
      return GetDsaPublicKey(dsa.ExportParameters(false));
    }

    public static DsaPublicKeyParameters GetDsaPublicKey(
      DSAParameters dp)
    {
      DsaValidationParameters validationParameters = (dp.Seed != null)
        ?  new DsaValidationParameters(dp.Seed, dp.Counter)
        :  null;

      DsaParameters parameters = new DsaParameters(
        new BigInteger(1, dp.P),
        new BigInteger(1, dp.Q),
        new BigInteger(1, dp.G),
        validationParameters);

      return new DsaPublicKeyParameters(
        new BigInteger(1, dp.Y),
        parameters);
    }

    public static AsymmetricCipherKeyPair GetRsaKeyPair(
      RSA rsa)
    {
      return GetRsaKeyPair(rsa.ExportParameters(true));
    }

    public static AsymmetricCipherKeyPair GetRsaKeyPair(
      RSAParameters rp)
    {
      BigInteger modulus = new BigInteger(1, rp.Modulus);
      BigInteger pubExp = new BigInteger(1, rp.Exponent);

      RsaKeyParameters pubKey = new RsaKeyParameters(
        false,
        modulus,
        pubExp);

      RsaPrivateCrtKeyParameters privKey = new RsaPrivateCrtKeyParameters(
        modulus,
        pubExp,
        new BigInteger(1, rp.D),
        new BigInteger(1, rp.P),
        new BigInteger(1, rp.Q),
        new BigInteger(1, rp.DP),
        new BigInteger(1, rp.DQ),
        new BigInteger(1, rp.InverseQ));

      return new AsymmetricCipherKeyPair(pubKey, privKey);
    }

    public static RsaKeyParameters GetRsaPublicKey(
      RSA rsa)
    {
      return GetRsaPublicKey(rsa.ExportParameters(false));
    }

    public static RsaKeyParameters GetRsaPublicKey(
      RSAParameters rp)
    {
      return new RsaKeyParameters(
        false,
        new BigInteger(1, rp.Modulus),
        new BigInteger(1, rp.Exponent));
    }

    public static AsymmetricCipherKeyPair GetKeyPair(AsymmetricAlgorithm privateKey)
    {
      if (privateKey is DSA)
      {
        return GetDsaKeyPair((DSA)privateKey);
      }

      if (privateKey is RSA)
      {
        return GetRsaKeyPair((RSA)privateKey);
      }

      throw new ArgumentException("Unsupported algorithm specified", "privateKey");
    }

    public static RSA ToRSA(RsaKeyParameters rsaKey)
    {
      RSAParameters rp = ToRSAParameters(rsaKey);
      RSACryptoServiceProvider rsaCsp = new RSACryptoServiceProvider();
      rsaCsp.ImportParameters(rp);
      return rsaCsp;
    }

    public static RSA ToRSA(RsaPrivateCrtKeyParameters privKey)
    {
      RSAParameters rp = ToRSAParameters(privKey);
      RSACryptoServiceProvider rsaCsp = new RSACryptoServiceProvider();
      rsaCsp.ImportParameters(rp);
      return rsaCsp;
    }

    public static RSAParameters ToRSAParameters(RsaKeyParameters rsaKey)
    {
      RSAParameters rp = new RSAParameters();
      rp.Modulus = rsaKey.Modulus.ToByteArrayUnsigned();
      if (rsaKey.IsPrivate)
        rp.D = rsaKey.Exponent.ToByteArrayUnsigned();
      else
        rp.Exponent = rsaKey.Exponent.ToByteArrayUnsigned();
      return rp;
    }

    public static RSAParameters ToRSAParameters(RsaPrivateCrtKeyParameters privKey)
    {
      RSAParameters rp = new RSAParameters();
      rp.Modulus = privKey.Modulus.ToByteArrayUnsigned();
      rp.Exponent = privKey.PublicExponent.ToByteArrayUnsigned();
      rp.D = privKey.Exponent.ToByteArrayUnsigned();
      rp.P = privKey.P.ToByteArrayUnsigned();
      rp.Q = privKey.Q.ToByteArrayUnsigned();
      rp.DP = privKey.DP.ToByteArrayUnsigned();
      rp.DQ = privKey.DQ.ToByteArrayUnsigned();
      rp.InverseQ = privKey.QInv.ToByteArrayUnsigned();
      return rp;
    }
  }
}

#endif