How can I encrypt text with aesKey and private cert in C#?

Here is the class that help you to perform Encryption/Decryption:

public static class DecryptionHelper
{
    private static string EncryptionDecryptionKey = "your_key";

    public static string Encrypt(string Text)
    {
        //var key = GenerateKey();
        var key = Encoding.UTF8.GetBytes(EncryptionDecryptionKey);

        var plainText = Text;
        var encryptedData = EncryptStringToBytes(key, plainText);

        return Convert.ToBase64String(encryptedData);
    }

    public static string Decrypt(string Text)
    {
        //var key = GenerateKey();
        var key = Encoding.UTF8.GetBytes(EncryptionDecryptionKey);

        byte[] encryptedData = Convert.FromBase64String(Text);
        var decryptedData = DecryptBytesToString(key, encryptedData);

        return decryptedData;
    }

    private static string DecryptBytesToString(byte[] key, byte[] data)
    {
        // IV was prepended to the encrypted bytes so peel that off
        Tuple<byte[], byte[]> splitResult = SplitByteArray(data);
        byte[] iv = splitResult.Item1;
        byte[] cipherText = splitResult.Item2;

        // Declare the string used to hold the decrypted text. 
        string plaintext;

        // Create an RijndaelManaged object 
        // with the specified key and IV. 
        using (var aes = CreateAes256Algorithm())
        {
            aes.Key = key;
            aes.IV = iv;

            // Create a decrytor to perform the stream transform.
            ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

            // Create the streams used for decryption. 
            using (var msDecrypt = new MemoryStream(cipherText))
            {
                using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (var srDecrypt = new StreamReader(csDecrypt))
                    {
                        // Read the decrypted bytes from the decrypting stream 
                        // and place them in a string.
                        plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }
        }
        return plaintext;
    }

    private static Tuple<byte[], byte[]> SplitByteArray(byte[] data)
    {
        byte[] first = new byte[16];
        Buffer.BlockCopy(data, 0, first, 0, first.Length);
        byte[] second = new byte[data.Length - first.Length];
        Buffer.BlockCopy(data, first.Length, second, 0, second.Length);
        return Tuple.Create(first, second);
    }

    private static byte[] GenerateKey()
    {
        using (var aes = CreateAes256Algorithm())
        {
            aes.GenerateKey();
            return aes.Key;
        }
    }

    private static RijndaelManaged CreateAes256Algorithm()
    {
        return new RijndaelManaged { KeySize = 256, BlockSize = 128 };
    }

    private static byte[] EncryptStringToBytes(byte[] key, string plainText)
    {
        byte[] encrypted;
        byte[] iv;

        // Create an RijndaelManaged object with the specified key and IV. 
        using (var aes = CreateAes256Algorithm())
        {
            aes.Key = key;
            aes.GenerateIV();

            iv = aes.IV;

            // Create a encrytor to perform the stream transform.
            ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);

            // Create the streams used for encryption. 
            using (var msEncrypt = new MemoryStream())
            {
                using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    using (var swEncrypt = new StreamWriter(csEncrypt))
                    {
                        //Write all data to the stream.
                        swEncrypt.Write(plainText);
                    }
                    // convert stream to bytes
                    encrypted = msEncrypt.ToArray();
                }
            }
        }

        // Prepend the iV to the encrypted bytes
        return CombineByteArrays(iv, encrypted);
    }

    private static byte[] CombineByteArrays(byte[] first, byte[] second)
    {
        byte[] ret = new byte[first.Length + second.Length];
        Buffer.BlockCopy(first, 0, ret, 0, first.Length);
        Buffer.BlockCopy(second, 0, ret, first.Length, second.Length);
        return ret;
    }
}

Then to use it like:

Keys.FacebookClientId = DecryptionHelper.Decrypt(FacebookClientId);

using System;
using System.Text;
using Org.BouncyCastle.OpenSsl;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Encodings;
using System.Security.Cryptography;
using System.IO;

public static string CreateSecureLoad(string unencryptedPayload, ref byte[] generatedAesKey)
{
// This method generates and returns a secure payload ​
    RijndaelManaged cryptoAlgo = new RijndaelManaged
    {
        Padding = PaddingMode.PKCS7,
        Mode = CipherMode.ECB,
        KeySize = 128,
        BlockSize = 128
    };​
         generatedAesKey = cryptoAlgo.Key;
         var clearTextArray = Encoding.UTF8.GetBytes(unencryptedPayload);
         var encryptor = cryptoAlgo.CreateEncryptor();​
         using (MemoryStream msEncrypt = new MemoryStream())
         {
             using (CryptoStream csEncrypt = new CryptoStream(
                 msEncrypt,
                 encryptor,
                 CryptoStreamMode.Write))
             {
                 csEncrypt.Write(clearTextArray);
                 csEncrypt.FlushFinalBlock();
                 var cipher = msEncrypt.ToArray();
                 return Convert.ToBase64String(cipher);
             }
         }
     }
    
public static string CreateSecureKey(byte[] aesKey, string privateKeyPEM)
     {
         // This method generates and returns a secure key
         // Accepts the string contents of the private key PEM file as input
 ​
         var encryptEngine = new Pkcs1Encoding(new RsaEngine());
 ​
         using (var textReader = new StringReader(privateKeyPEM))
         {
             var pemReader = new PemReader(textReader);
             var keyPair = (AsymmetricCipherKeyPair)pemReader.ReadObject();
             encryptEngine.Init(true, keyPair.Private);
         }
 ​
         var encrypted = Convert.ToBase64String(
             encryptEngine.ProcessBlock(
                 aesKey,
                 0,
                 aesKey.Length));
         return encrypted;
     }
    
static void Main(string[] args)
     {
         String payload = "some json";
 ​
         byte[] generatedAesKey = new byte[16];
         var privateKeyPEM = File.ReadAllText("privatekey.pem");
 ​
         var securePayload = CreateSecureLoad(payload, ref generatedAesKey);
         var secureKey = CreateSecureKey(generatedAesKey, privateKeyPEM);
 ​
         // Return encrypted key
         Console.WriteLine("secureKey: " + secureKey);
 ​
         // Return encrypted payload
         Console.WriteLine("securePayload: " + securePayload);​
         Console.ReadLine();​
     }
 }