C# crypt.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Security.Cryptography;

namespace Signer
{
    public enum HashType
    {
        SHA1,
        SHA256,
        SHA512
    }

    public static class Crypt
    {
        private static Random R = null;

        private const int BUFFER = 1024 * 1024;

        /// <summary>
        /// Generates a random Password
        /// </summary>
        /// <param name="Length">Password Length</param>
        /// <returns>new password</returns>
        public static string randomPassword(int Length)
        {
            StringBuilder SB = new StringBuilder(Length);
            if (R == null)
            {
                R = new Random();
            }
            for (int i = 0; i < Length; i++)
            {
                SB.Append(Base.SYM_PWDMAP[R.Next(Base.SYM_PWDMAP.Length)]);
            }
            return SB.ToString();
        }

        /// <summary>
        /// Generates random bytes
        /// </summary>
        /// <param name="Length">Number of bytes</param>
        /// <returns>What do you expect?</returns>
        public static byte[] randomBytes(int Length)
        {
            byte[] b = new byte[Length];
            if (R == null)
            {
                R = new Random();
            }
            R.NextBytes(b);
            return b;
        }

        /// <summary>
        /// creates a stream from a byte array
        /// </summary>
        /// <param name="b">byte array</param>
        /// <returns>Memory stream</returns>
        public static MemoryStream ToStream(byte[] b)
        {
            return new MemoryStream(b);
        }

        /// <summary>
        /// Signs data from a stream
        /// </summary>
        /// <param name="In">Input data</param>
        /// <param name="K">Key to sign (must have private key)</param>
        /// <returns>sign block</returns>
        public static byte[] Sign(Stream In, Key K)
        {
            var RCSP = K.GetRCSP();
            byte[] hash = GetHash(In);
            byte[] sig = RCSP.SignHash(hash, HashType.SHA512.ToString());
            RCSP.Clear();
            return sig;
        }

        /// <summary>
        /// Verifies a Signature
        /// </summary>
        /// <param name="In">Input data</param>
        /// <param name="signature">Signature</param>
        /// <param name="K">Key to verify against</param>
        /// <returns>true, if verified duccessfully</returns>
        public static bool Verify(Stream In, byte[] signature, Key K)
        {
            var RCSP = K.GetRCSP();
            byte[] hash = GetHash(In);
            bool ok = RCSP.VerifyHash(hash, HashType.SHA512.ToString(), signature);
            RCSP.Clear();
            return ok;
        }

        /// <summary>
        /// Encrypts a stream into another
        /// </summary>
        /// <param name="In">Input data (unencrypted)</param>
        /// <param name="Out">Output data (encrypted, writeable)</param>
        /// <param name="K">Encryption key (must have private key)</param>
        /// <returns>password for decryption</returns>
        public static void Encrypt(Stream In, Stream Out, Key K)
        {
            var RCSP=K.GetRCSP();
            In.Seek(0, SeekOrigin.Begin);
            byte[] dec = new byte[BUFFER];

            byte[] PWD = randomBytes(Base.SYM_PW);
            byte[] IV = randomBytes(Base.SYM_IV);

            RijndaelManaged RM = new RijndaelManaged();

            byte[] tmp = RCSP.Encrypt(PWD, true);
            Out.Write(tmp, 0, Base.ASYM_RSASIZE);
            tmp = RCSP.Encrypt(IV, true);
            Out.Write(tmp, 0, Base.ASYM_RSASIZE);

            RCSP.Clear();
            CryptoStream CS = new CryptoStream(Out, RM.CreateEncryptor(PWD, IV), CryptoStreamMode.Write);

            for (int i = 0; i < In.Length; i += BUFFER)
            {
                int readed = In.Read(dec, 0, BUFFER);
                if(readed<BUFFER)
                {
                    Array.Resize<byte>(ref dec, readed);
                }
                CS.Write(dec, 0, dec.Length);
            }
            CS.Close();
            CS.Dispose();
        }

        /// <summary>
        /// Decrypts a stream into another
        /// </summary>
        /// <param name="In">Input data (encrypted)</param>
        /// <param name="Out">Output data (unencrypted, writeable)</param>
        /// <param name="K">Decryption key</param>
        public static bool Decrypt(Stream In, Stream Out, Key K)
        {
            var RCSP = K.GetRCSP();
            byte[] enc = new byte[BUFFER];
            byte[] PWD = new byte[Base.ASYM_RSASIZE];
            byte[] IV = new byte[Base.ASYM_RSASIZE];
            int readed;
            CryptoStream CS;
            RijndaelManaged RM = new RijndaelManaged();

            //do not even try for pubkey only
            if (RCSP.PublicOnly)
            {
                return false;
            }

            In.Seek(0, SeekOrigin.Begin);

            In.Read(PWD, 0, Base.ASYM_RSASIZE);
            In.Read(IV, 0, Base.ASYM_RSASIZE);
            try
            {
                PWD = RCSP.Decrypt(PWD, true);
                IV = RCSP.Decrypt(IV, true);
                CS = new CryptoStream(In, RM.CreateDecryptor(PWD, IV), CryptoStreamMode.Read);
            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
                return false;
            }

            CS = new CryptoStream(In, RM.CreateDecryptor(PWD, IV), CryptoStreamMode.Read);


            RCSP.Clear();

            for (int i = 0; i < In.Length; i += BUFFER)
            {
                try
                {
                    readed = CS.Read(enc, 0, BUFFER);
                }
                catch
                {
                    CS.Close();
                    CS.Clear();
                    return false;
                }
                if (readed < BUFFER)
                {
                    Array.Resize<byte>(ref enc, readed);
                }
                Out.Write(enc, 0, enc.Length);
            }
            Out.Close();
            CS.Close();
            CS.Dispose();
            return true;
        }

        /// <summary>
        /// Generates a SHA-512 hash from data in a stream
        /// </summary>
        /// <param name="In">Input stream</param>
        /// <returns>hash</returns>
        public static byte[] GetHash(Stream In)
        {
            return GetHash(In, Base.CRYPT_HASH);
        }

        /// <summary>
        /// Generates a hash from data in a stream
        /// </summary>
        /// <param name="In">Input stream</param>
        /// <param name="Algorithm">Hash algorithm to use</param>
        /// <returns>hash</returns>
        public static byte[] GetHash(Stream In, HashType Algorithm)
        {
            var H = HashAlgorithm.Create(Algorithm.ToString());
            In.Seek(0, SeekOrigin.Begin);
            byte[] yay = H.ComputeHash(In);
            H.Clear();
            return yay;
        }
    }
}