Szyfrowanie plików XML

Witam
Mam taki mały problem, wzorując się na szyfrowaniu plików na stronie Microsoftu nie zbyt działa mi poprawnie w aktualnej wersji ma problem przy deszyfracji z odczytem klucza a we wcześniejszej pliki z innej maszyny nie mogły być rozszyfrowane na moim komputrze czy innej maszynie. Nie zbyt wiem dlaczego nie może go znaleźć ponieważ klucz zaszywam w dokumencie xml.

Potrzebowałbym szybkiej pomocy w rozwiązaniu tego problemu z góry dziękuję

Tutaj troche mojego kodu

private static void EncryptXML(XmlDocument Xml, string EncryptElement, string KeyName)
        {
            
            if (Xml == null || EncryptElement == null)
                throw new ArgumentNullException();

            var cspParams = new CspParameters { KeyContainerName = "XML_RSA_FTP_KEY" };
            cspParams.Flags = CspProviderFlags.UseMachineKeyStore;

            var rsaAlg = new RSACryptoServiceProvider(cspParams);

            XmlElement element = Xml.GetElementsByTagName(EncryptElement)[0] as XmlElement;

            try
            {
                RijndaelManaged SKey = new RijndaelManaged();
                SKey.KeySize = 256;

                EncryptedXml encryptedXml = new EncryptedXml();
                byte[] encryptedElement = encryptedXml.EncryptData(element, SKey, false);

                EncryptedData ElementData = new EncryptedData();
                ElementData.Type = EncryptedXml.XmlEncElementUrl;

                ElementData.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
                EncryptedKey ek = new EncryptedKey();

                byte[] KeyToEncrypt = EncryptedXml.EncryptKey(SKey.Key, rsaAlg, false);

                ek.CipherData = new CipherData(KeyToEncrypt);
                ek.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncRSA15Url);

                DataReference dRef = new DataReference();
                dRef.Uri = "#" + 2;

                ek.AddReference(dRef);

                

                var property = new XmlDocument().CreateElement("EncryptionProperty", EncryptedXml.XmlEncNamespaceUrl);

                var Salt = "32324552";


                property.InnerText = RijndaelManagedEncryption.EncryptRijndael(Convert.ToBase64String(rsaAlg.ExportCspBlob(true)), Salt);

                var encProperty = new EncryptionProperty(property);

                ek.AddProperty(encProperty);

                KeyInfoName kin = new KeyInfoName();

                kin.LoadXml(property);

                ek.KeyInfo.AddClause(kin);

                ElementData.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));

                ElementData.CipherData.CipherValue = encryptedElement;

                EncryptedXml.ReplaceElement(element, ElementData, false);
            }
            catch (Exception ex)
            {
                throw;
            }
            //ElementData.KeyInfo = new KeyInfo();

            //KeyInfoName KeyInformation = new KeyInfoName();
            //KeyInformation.Value = KeyName;
            //ek.KeyInfo.AddClause(KeyInformation);
            //ElementData.KeyInfo.AddClause(new KeyInfoEncryptedKey(ek));

            //ElementData.CipherData.CipherValue = encryptedElement;

            //EncryptedXml.ReplaceElement(element, ElementData, false);
        }
        private static void DecryptXML(XmlDocument Xml, RSA key, string KeyName)
        {
            if (Xml == null || key == null || KeyName == null)
                throw new ArgumentNullException();

            XmlDocument xmlDoc = Xml;

            CspParameters cspParams = new CspParameters();
            cspParams.KeyContainerName = "XML_RSA_FTP_KEY";
            cspParams.Flags = CspProviderFlags.UseMachineKeyStore;

            RSACryptoServiceProvider ftpkey = new RSACryptoServiceProvider(cspParams);
            var Salt = "32324552";
            var KeyInfo = xmlDoc.GetElementsByTagName("EncryptionProperty")[0].InnerText;
            ftpkey.ImportCspBlob(Convert.FromBase64String(RijndaelManagedEncryption.DecryptRijndael(KeyInfo,
                Salt)));


            EncryptedXml encryptedXml = new EncryptedXml(xmlDoc);
            encryptedXml.AddKeyNameMapping("ftpkey", ftpkey);
            encryptedXml.DecryptDocument();
        }
        #endregion
    }```


```c#
 public class RijndaelManagedEncryption
    {
        #region Consts
        /// <summary>
        /// Change the Inputkey GUID when you use this code in your own program.
        /// Keep this inputkey very safe and prevent someone from decoding it some way!!
        /// </summary>
        internal const string Inputkey = "560A18CD-6346-4CF0-A2E8-671F9B6B9EA9";
        #endregion

        #region Rijndael Encryption

        /// <summary>
        /// Encrypt the given text and give the byte array back as a BASE64 string
        /// </summary>
        /// <param name="text" />The text to encrypt
        /// <param name="salt" />The pasword salt
        /// <returns>The encrypted text</returns>
        public static string EncryptRijndael(string text, string salt)
        {
            if (string.IsNullOrEmpty(text))
                throw new ArgumentNullException("text");

            var aesAlg = NewRijndaelManaged(salt);

            var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
            var msEncrypt = new MemoryStream();
            using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
            using (var swEncrypt = new StreamWriter(csEncrypt))
            {
                swEncrypt.Write(text);
            }

            return Convert.ToBase64String(msEncrypt.ToArray());
        }
        #endregion

        /// <summary>
        /// Checks if a string is base64 encoded
        /// </summary>
        /// <param name="base64String" />The base64 encoded string
        /// <returns>Base64 encoded stringt</returns>
        public static bool IsBase64String(string base64String)
        {
            base64String = base64String.Trim();
            return (base64String.Length % 4 == 0) &&
                   Regex.IsMatch(base64String, @"^[a-zA-Z0-9\+/]*={0,3}$", RegexOptions.None);

        }

        /// <summary>
        /// Decrypts the given text
        /// </summary>
        /// <param name="cipherText" />The encrypted BASE64 text
        /// <param name="salt" />The pasword salt
        /// <returns>The decrypted text</returns>
        public static string DecryptRijndael(string cipherText, string salt)
        {
            if (string.IsNullOrEmpty(cipherText))
                throw new ArgumentNullException("cipherText");

            if (!IsBase64String(cipherText))
                throw new Exception("The cipherText input parameter is not base64 encoded");

            string text;

            var aesAlg = NewRijndaelManaged(salt);
            var decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
            var cipher = Convert.FromBase64String(cipherText);

            using (var msDecrypt = new MemoryStream(cipher))
            {
                using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (var srDecrypt = new StreamReader(csDecrypt))
                    {
                        text = srDecrypt.ReadToEnd();
                    }
                }
            }
            return text;
        }
        #endregion

        #region NewRijndaelManaged
        /// <summary>
        /// Create a new RijndaelManaged class and initialize it
        /// </summary>
        /// <param name="salt" />The pasword salt
        /// <returns></returns>
        private static RijndaelManaged NewRijndaelManaged(string salt)
        {
            if (salt == null) throw new ArgumentNullException("salt");
            var saltBytes = Encoding.ASCII.GetBytes(salt);
            var key = new Rfc2898DeriveBytes(Inputkey, saltBytes);

            var aesAlg = new RijndaelManaged();
            aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
            aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8);

            return aesAlg;
        }
        #endregion
    }