Crypto.cs

using System;
using System.IO;
using System.Security.Authentication;
using System.Security.Cryptography;
using System.Threading.Tasks;
using Waher.Runtime.IO;
 
namespace Waher.Security
{
    public static class Crypto
    {
        public const SslProtocols SecureTls = (SslProtocols)((int)SslProtocols.Tls12 | 12288 /* TLS 1.3 */);
 
        public const SslProtocols TlsOnly = (SslProtocols)((int)SslProtocols.Tls | (int)SslProtocols.Tls11 | (int)SslProtocols.Tls12 | 12288 /* TLS 1.3 */);
 
        public static Task CryptoTransform(ICryptoTransform Transform, Stream Source, Stream Destination)
        {
            return CryptoTransform(Transform, Source, Destination, 65536);
        }
 
        public static async Task CryptoTransform(ICryptoTransform Transform, Stream Source, Stream Destination, int BufferSize)
        {
            if (BufferSize <= 0)
                throw new ArgumentException("Invalid buffer size.", nameof(BufferSize));
 
            long l = Source.Length;
 
            BufferSize = (int)Math.Min(l, BufferSize);
 
            byte[] Input = new byte[BufferSize];
            byte[] Output = new byte[BufferSize];
            int j;
 
            while (l > 0)
            {
                j = (int)Math.Min(BufferSize, l);
                await Source.ReadAllAsync(Input, 0, j);
 
                l -= j;
                if (l <= 0)
                {
                    Output = Transform.TransformFinalBlock(Input, 0, j);
                    await Destination.WriteAsync(Output, 0, Output.Length);
                }
                else
                {
                    j = Transform.TransformBlock(Input, 0, j, Output, 0);
                    await Destination.WriteAsync(Output, 0, j);
                }
            }
        }
 
        public static async Task<bool> CopyAsync(Stream From, Stream To, long DataLen)
        {
            if (DataLen > 0)
            {
                int BufSize = (int)Math.Min(DataLen, 65536);
                byte[] Buffer = new byte[BufSize];
 
                while (DataLen > 0)
                {
                    if (DataLen < BufSize)
                        BufSize = (int)DataLen;
 
                    if (await From.TryReadAllAsync(Buffer, 0, BufSize) != BufSize)
                        return false;
 
                    await To.WriteAsync(Buffer, 0, BufSize);
                    DataLen -= BufSize;
                }
            }
 
            return true;
        }
    }
}