The length of the data to decrypt is not valid for the size of this key при попытки расшифровать байты блоками

    List<byte> Decrypt(byte[] buffer, string private_key)
    {
 
        string pathTo = FileSystem.Current.CacheDirectory;
        if (Directory.Exists($"{pathTo}/temp"))
        {
            Directory.Delete($"{pathTo}/temp", true);
 
        }
 
        using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
        {
 
         
            List<byte> returnTo = new List<byte>();
        
 
                rsa.FromXmlString(private_key);
        
 
 
            Directory.CreateDirectory($"{pathTo}/temp");
            FileStream fs = File.Create($"{pathTo}/temp/decrypt.txt");
            fs.Write(buffer, 0, buffer.Length);
            fs.Close();
            using (FileStream fstreamIn = File.OpenRead($"{pathTo}/temp/decrypt.txt"))
            {
 
 
                byte[] buf = new byte[256];
 
                if (fstreamIn.Length <= 256)
                {
                    int bytesRead = fstreamIn.Read(buf, 0, buf.Length);
 
                    if (bytesRead != 0)
                    {
                        byte[] decrypted = rsa.Decrypt(buf, true);
 
                        for (int i = 0; i < decrypted.Length; i++)
                        {
                            returnTo.Add(decrypted[i]);
                        }
                    }
                }
                else
                {
 
                    
                        for (; ; )
                        {
 
                            int bytesRead = fstreamIn.Read(buf, 0, buf.Length);
 
                            Console.WriteLine(bytesRead + "!!!!!!!!!!!!!!!!!");
                        if (bytesRead == 0) break;
 
 
                        else if (bytesRead < 256)
                        {
                            byte[] current = new byte[bytesRead];
                            for (int i = 0; i < bytesRead; i++)
                            {
                                current[i] = buf[i];
 
                            }
                            byte[] decrypted = rsa.Decrypt(current, true);
 
                            for (int i = 0; i < decrypted.Length; i++)
                            {
                                returnTo.Add(decrypted[i]);
                            }
                        }
                        else
                        {
                            byte[] decrypted = rsa.Decrypt(buf, true);
 
                            for (int i = 0; i < decrypted.Length; i++)
                            {
                                returnTo.Add(decrypted[i]);
                            }
                        }
 
                            
 
 
 
                        }
                    
                    
                   
                
 
                }
 
                fstreamIn.Close();
                Directory.Delete($"{pathTo}/temp", true);
 
 
                return returnTo;
            }
 
        }
 
 
 
 
 
 
 
 
 
}

static List<byte> Decrypt(byte[] buffer, TcpClient tcpIP)
{
 
    IPEndPoint remoteIpEndPoint = tcpIP.Client.RemoteEndPoint as IPEndPoint;
   
    string ip  = remoteIpEndPoint.Address.ToString();
 
    RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
 
    List<byte> returnTo = new List<byte>();
    rsa.FromXmlString(_private);
   
        Directory.CreateDirectory($"{Directory.GetCurrentDirectory()}/temp/{ip}");
        FileStream fs = File.Create($"{Directory.GetCurrentDirectory()}/temp/{ip}/TEMP.txt");
            fs.Write(buffer, 0, buffer.Length);
            fs.Close();
        using (FileStream fstreamIn = File.OpenRead($"{Directory.GetCurrentDirectory()}/temp/{ip}/TEMP.txt"))
        {
          
       
            byte[] buf = new byte[256];
 
            if (fstreamIn.Length <= 256)
            {
                int bytesRead = fstreamIn.Read(buf, 0, buf.Length);
 
                if (bytesRead != 0)
                {
                    byte[] decrypted = rsa.Decrypt(buf, true);
                
                    for (int i = 0; i < decrypted.Length; i++)
                    {
                        returnTo.Add(decrypted[i]);
                    }
                }
            }
            else
            {
                
                for (; ; )
                {
                int bytesRead = fstreamIn.Read(buf, 0, buf.Length);
                Console.WriteLine(bytesRead + "!!!!!!!!!!!!!!!!!");
 
                if (bytesRead == 0) break;
 
                    byte[] decrypted = rsa.Decrypt(buf, true);
 
              
                    for (int i = 0; i < decrypted.Length; i++)
                    {
                        returnTo.Add(decrypted[i]);
                    }
                
             
              
                   
                }
              
            }
 
        fstreamIn.Close();
        Directory.Delete($"{Directory.GetCurrentDirectory()}/temp/{ip}", true);
       
 
            return returnTo;
 
        }
 
 
    
   
 
}

$"{Directory.GetCurrentDirectory()}/temp/{ip}/TEMP.txt"

List<byte> Decrypt(byte[] buffer, string private_key)
{
    var returnTo = new List<byte>(0);
    using (var rsa = new RSACryptoServiceProvider())
    {
        rsa.FromXmlString(private_key);
        
        const int CHUNK = 256;
        int chunks = buffer.Length / CHUNK + (buffer.Length % CHUNK > 0 ? 1 : 0);
        
        byte[] decrypted = new byte[CHUNK];
        for (int i=0; i<chunks; i++)
        {
            int offset = i*CHUNK;
            int size = Math.Min(CHUNK, buffer.Length-offset);
            ReadOnlySpan<byte> bufferSpan = buffer.AsSpan()[offset..(offset+size)];
            
            int bytesWritten = rsa.Decrypt(bufferSpan, decrypted.AsSpan(), RSAEncryptionPadding.OaepSHA1);
            
            returnTo.Capacity += bytesWritten;
            returnTo.AddRange(decrypted.AsSpan()[..bytesWritten]);
        }
    }
    
    return returnTo;
}

static List<byte> EncryptFile(byte[] buffer, string key)
 {
     List<byte> result = new List<byte>();
     string pathTo = Directory.GetCurrentDirectory();
 
     using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
     {
         rsa.FromXmlString(key);
 
         FileStream fs = File.Create($"{pathTo}/TEMP.txt");
         fs.Write(buffer, 0, buffer.Length);
         fs.Close();
         using (FileStream fstreamOut = new FileStream($"{pathTo}/TEMP.txt", FileMode.Open, FileAccess.Read))
         {
      
             byte[] buf = new byte[128];
             for (; ; )
             {
                 int bytesRead = fstreamOut.Read(buf, 0, buf.Length);
                 if (bytesRead == 0) break;
                 byte[] encrypted = bytesRead == buf.Length ? rsa.Encrypt(buf, true) : rsa.Encrypt(buf.Take(bytesRead).ToArray(), true);
                 for (int i = 0; i < encrypted.Length; i++)
                 {
                     result.Add(encrypted[i]);
                 }
             }
             fstreamOut.Close();
             File.Delete($"{pathTo}/TEMP.txt");
           
             return result;
         }
     }
 }

buf.Take(bytesRead)

void Main()
{
 
    var keySize=2048;
    var rsaCryptoServiceProvider = new RSACryptoServiceProvider(keySize);
 
    var cipherText = Encrypt("hello world", rsaCryptoServiceProvider.ExportParameters(false));
    var plainText = Decrypt(cipherText, rsaCryptoServiceProvider.ExportParameters(true));
    Console.WriteLine(plainText);
 
}
public string Encrypt(string data, RSAParameters key)
{
 
    using (var rsa = new RSACryptoServiceProvider())
    {
        rsa.ImportParameters(key);
        var byteData = Encoding.UTF8.GetBytes(data);
        var encryptData = rsa.Encrypt(byteData, false);
        return Convert.ToBase64String(encryptData);
    }
}
 
public string Decrypt(string cipherText, RSAParameters key)
{
 
    using (var rsa = new RSACryptoServiceProvider())
    {
        var cipherByteData = Convert.FromBase64String(cipherText);
        rsa.ImportParameters(key);
 
        var encryptData = rsa.Decrypt(cipherByteData, false);
        return Encoding.UTF8.GetString(encryptData);
    }
}

using System;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
 
namespace OrangeKeks
{
    internal class Program
    {
        static void Main(string[] args)
        {
            var keySize = 2048;
            var rsaCryptoServiceProvider = new RSACryptoServiceProvider(keySize);
            var publikKey = rsaCryptoServiceProvider.ExportParameters(false);
            var privateKey = rsaCryptoServiceProvider.ExportParameters(true);
 
            {
                var testText = "1234";
                var testTextBuffer = Encoding.UTF8.GetBytes(testText);
 
                var sourceStream = new MemoryStream();
                sourceStream.Write(testTextBuffer, 0, testTextBuffer.Length);
                sourceStream.Position = 0;
 
                var encryptedStream = new MemoryStream();
                Encrypt(sourceStream, encryptedStream, publikKey);
 
                encryptedStream.Position = 0;
 
                var decryptedStream = new MemoryStream();
                Decrypt(encryptedStream, decryptedStream, privateKey);
 
                var testText2 = Encoding.UTF8.GetString(decryptedStream.ToArray());
                Console.WriteLine(testText2);
            }
 
            {
                using (var sourceStream = new FileStream("R:\\test.bin", FileMode.Open, FileAccess.Read, FileShare.Read, 1024 * 1024))
                {
                    using (var encryptedStream = new FileStream("R:\\test.encrypted", FileMode.Create, FileAccess.Write, FileShare.Read, 1024 * 1024))
                    {
                        Encrypt(sourceStream, encryptedStream, publikKey);
                    }
                }
 
                using (var encryptedStream = new FileStream("R:\\test.encrypted", FileMode.Open, FileAccess.Read, FileShare.Read, 1024 * 1024))
                {
                    using (var decryptedStream = new FileStream("R:\\test2.bin", FileMode.Create, FileAccess.Write, FileShare.Read, 1024 * 1024))
                    {
                        Decrypt(encryptedStream, decryptedStream, privateKey);
                    }
                }
            }
        }
 
        static void Encrypt(Stream source, Stream output, RSAParameters key)
        {
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(key);
                var buffer = new byte[128];
                int position = 0;
 
                while (true)
                {
                    var readed = source.Read(buffer, 0, buffer.Length);
 
                    if (readed == 0) break;
 
                    // Только для прогресса в консоли.
                    if (source.Position > (65536))
                    {
                        Console.WriteLine("{0:n0}", source.Position);
                        position += 65536;
                    }
 
                    var encrypted = rsa.Encrypt((readed < buffer.Length) ? buffer.Take(readed).ToArray() : buffer, false);
 
                    output.Write(encrypted, 0, encrypted.Length);
                }
            }
        }
 
        static void Decrypt(Stream source, Stream output, RSAParameters key)
        {
            using (var rsa = new RSACryptoServiceProvider())
            {
                rsa.ImportParameters(key);
                var buffer = new byte[256];
                int position = 0;
 
                while (true)
                {
                    var readed = source.Read(buffer, 0, buffer.Length);
 
                    if (readed == 0) break;
 
                    // Только для прогресса в консоли.
                    if (source.Position > (65536))
                    {
                        Console.WriteLine("{0:n0}", source.Position);
                        position += 65536;
                    }
 
                    var decryptData = rsa.Decrypt((readed < buffer.Length) ? buffer.Take(readed).ToArray() : buffer, false);
 
                    output.Write(decryptData, 0, decryptData.Length);
                }
            }
        }
    }
}

 static List<byte> Encrypt(byte[] buffer, string key)
 {
     var returnTo = new List<byte>(0);
     using (var rsa = new RSACryptoServiceProvider())
     {
         rsa.FromXmlString(key);
 
         const int CHUNK = 256;
         int chunks = buffer.Length / CHUNK + (buffer.Length % CHUNK > 0 ? 1 : 0);
 
         byte[] decrypted = new byte[CHUNK];
         for (int i = 0; i < chunks; i++)
         {
             Console.WriteLine("3");
             int offset = i * CHUNK;
             int size = Math.Min(CHUNK, buffer.Length - offset);
             ReadOnlySpan<byte> bufferSpan = buffer.AsSpan()[offset..(offset + size)];
 
             int bytesWritten = rsa.Encrypt(bufferSpan, decrypted.AsSpan(), RSAEncryptionPadding.OaepSHA1);
 
             returnTo.Capacity += bytesWritten;
             returnTo.AddRange(decrypted.AsSpan()[..bytesWritten]);
         }
     }
 
     return returnTo;
 }