Read RSA PrivateKey in C# and Bouncy Castle

I have successfully written to public and private key files with OpenSSL format.

Files:

And public key contains just the public key portion of course.

After encrypting my message using the public key. I want to read the private key file and decrypt it but it's not working. I'm getting exceptions trying to read the private key saying can't cast object to asymmetriccipherkey.

Here is my code:

public static AsymmetricKeyParameter ReadAsymmetricKeyParameter(string pemFilename)
{
    var fileStream = System.IO.File.OpenText(pemFilename);
    var pemReader = new Org.BouncyCastle.OpenSsl.PemReader(fileStream);
    var KeyParameter = (Org.BouncyCastle.Crypto.AsymmetricKeyParameter)pemReader.ReadObject();
    return KeyParameter;
}

static void Encrypt2(string publicKeyFileName, string inputMessage, string encryptedFileName)
    {   
        UTF8Encoding utf8enc = new UTF8Encoding();
        FileStream encryptedFile = null;

        try
        {
            // Converting the string message to byte array
            byte[] inputBytes = utf8enc.GetBytes(inputMessage);

            // RSAKeyPairGenerator generates the RSA Key pair based on the random number and strength of key required
            /*RsaKeyPairGenerator rsaKeyPairGnr = new RsaKeyPairGenerator();
            rsaKeyPairGnr.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 512));
            Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair = rsaKeyPairGnr.GenerateKeyPair();
            */

            AsymmetricKeyParameter publicKey = ReadAsymmetricKeyParameter(publicKeyFileName);

            // Creating the RSA algorithm object
            IAsymmetricBlockCipher cipher = new RsaEngine();

            // Initializing the RSA object for Encryption with RSA public key. Remember, for encryption, public key is needed
            cipher.Init(true, publicKey);

            //Encrypting the input bytes
            byte[] cipheredBytes = cipher.ProcessBlock(inputBytes, 0, inputMessage.Length);

            //Write the encrypted message to file
            // Write encrypted text to file
            encryptedFile = File.Create(encryptedFileName);
            encryptedFile.Write(cipheredBytes, 0, cipheredBytes.Length);
        }
        catch (Exception ex)
        {
            // Any errors? Show them
            Console.WriteLine("Exception encrypting file! More info:");
            Console.WriteLine(ex.Message);
        }
        finally
        {
            // Do some clean up if needed
            if (encryptedFile != null)
            {
                encryptedFile.Close();
            }
        }

    }

Here is the decrypt function. 2nd one is without using Bouncy Castle, however, I'd rather use Bouncy Castle since later I'll be also encrypting and decrypting in Java.

static void Decrypt2(string privateKeyFileName, string encryptedFileName, string plainTextFileName)
    {
        UTF8Encoding utf8enc = new UTF8Encoding();
        FileStream encryptedFile = null;
        StreamWriter plainFile = null;
        byte[] encryptedBytes = null;
        string plainText = "";

        try
        {
            // Converting the string message to byte array
            //byte[] inputBytes = utf8enc.GetBytes(inputMessage);

            // RSAKeyPairGenerator generates the RSA Key pair based on the random number and strength of key required
            /*RsaKeyPairGenerator rsaKeyPairGnr = new RsaKeyPairGenerator();
            rsaKeyPairGnr.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 512));
            Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair = rsaKeyPairGnr.GenerateKeyPair();
            */


            StreamReader sr = File.OpenText(privateKeyFileName);
            PemReader pr = new PemReader(sr);

            PemReader pemReader = new PemReader(new StringReader(privateKeyFileName));
            AsymmetricCipherKeyPair keyPair = (AsymmetricCipherKeyPair)pemReader.ReadObject();
            Console.WriteLine(keyPair.ToString());
            AsymmetricKeyParameter privatekey = keyPair.Private;


            Console.WriteLine(pr.ReadPemObject());
            AsymmetricCipherKeyPair KeyPair = (AsymmetricCipherKeyPair)pr.ReadObject();

            AsymmetricKeyParameter privateKey = ReadAsymmetricKeyParameter(privateKeyFileName);

            // Creating the RSA algorithm object
            IAsymmetricBlockCipher cipher = new RsaEngine();
            Console.WriteLine("privateKey: " + privateKey.ToString());

            // Initializing the RSA object for Decryption with RSA private key. Remember, for decryption, private key is needed
            //cipher.Init(false, KeyPair.Private);
            //cipher.Init(false, KeyPair.Private);
            cipher.Init(false, keyPair.Private);    

            // Read encrypted text from file
            encryptedFile = File.OpenRead(encryptedFileName);
            encryptedBytes = new byte[encryptedFile.Length];
            encryptedFile.Read(encryptedBytes, 0, (int)encryptedFile.Length);

            //Encrypting the input bytes
            //byte[] cipheredBytes = cipher.ProcessBlock(inputBytes, 0, inputMessage.Length);
            byte[] cipheredBytes = cipher.ProcessBlock(encryptedBytes, 0, encryptedBytes.Length);

            //Write the encrypted message to file
            // Write encrypted text to file
            plainFile = File.CreateText(plainTextFileName);
            plainText = Encoding.Unicode.GetString(cipheredBytes);
            plainFile.Write(plainText);
        }
        catch (Exception ex)
        {
            // Any errors? Show them
            Console.WriteLine("Exception encrypting file! More info:");
            Console.WriteLine(ex.Message);
        }
        finally
        {
            // Do some clean up if needed
            if (plainFile != null)
            {
                plainFile.Close();
            }
            if (encryptedFile != null)
            {
                encryptedFile.Close();
            }
        }
    }


    // Decrypt a file
    static void Decrypt(string privateKeyFileName, string encryptedFileName, string plainFileName)
    {
        // Variables
        CspParameters cspParams = null;
        RSACryptoServiceProvider rsaProvider = null;
        StreamReader privateKeyFile = null;
        FileStream encryptedFile = null;
        StreamWriter plainFile = null;
        string privateKeyText = "";
        string plainText = "";
        byte[] encryptedBytes = null;
        byte[] plainBytes = null;

        try
        {
            // Select target CSP
            cspParams = new CspParameters();
            cspParams.ProviderType = 1; // PROV_RSA_FULL 
            //cspParams.ProviderName; // CSP name
            rsaProvider = new RSACryptoServiceProvider(cspParams);

            // Read private/public key pair from file
            privateKeyFile = File.OpenText(privateKeyFileName);
            privateKeyText = privateKeyFile.ReadToEnd();

            // Import private/public key pair
            rsaProvider.FromXmlString(privateKeyText);

            // Read encrypted text from file
            encryptedFile = File.OpenRead(encryptedFileName);
            encryptedBytes = new byte[encryptedFile.Length];
            encryptedFile.Read(encryptedBytes, 0, (int)encryptedFile.Length);

            // Decrypt text
            plainBytes = rsaProvider.Decrypt(encryptedBytes, false);

            // Write decrypted text to file
            plainFile = File.CreateText(plainFileName);
            plainText = Encoding.Unicode.GetString(plainBytes);
            plainFile.Write(plainText);
        }
        catch (Exception ex)
        {
            // Any errors? Show them
            Console.WriteLine("Exception decrypting file! More info:");
            Console.WriteLine(ex.Message);
        }
        finally
        {
            // Do some clean up if needed
            if (privateKeyFile != null)
            {
                privateKeyFile.Close();
            }
            if (encryptedFile != null)
            {
                encryptedFile.Close();
            }
            if (plainFile != null)
            {
                plainFile.Close();
            }
        }

    } // Decrypt

Any help would be greatly appreciated!

I figured this out. Basically to read a private openssl key using BouncyCastle and C# is like this:

static AsymmetricKeyParameter readPrivateKey(string privateKeyFileName)
{
    AsymmetricCipherKeyPair keyPair;

    using (var reader = File.OpenText(privateKeyFileName))
        keyPair = (AsymmetricCipherKeyPair)new PemReader(reader).ReadObject();

    return keyPair.Private;
}

Then this key can be used to decrypt data such as below:

AsymmetricKeyParameter key = readPrivateKey(pemFilename);       
RsaEngine e = new RsaEngine();      
e.Init(false, key);

byte[] decipheredBytes = e.ProcessBlock(cipheredData, 0, cipheredData.Length);