code/Encryption/BinaryStream.cs

Go to the documentation of this file.

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

namespace Sylloge.Encryption
{
    public class BinaryStream : IDisposable
    {
        public enum StreamType
        {
            Encrypt,
            Decrypt
        }

        public enum AlgorithmType
        {
            AES,
            AES_Rijndael,
            TripleDES
        }

        private System.Security.Cryptography.SymmetricAlgorithm m_algo;
        private System.Security.Cryptography.CryptoStream m_crypto;
        private System.IO.MemoryStream m_stream;

        public StreamType Type { get; protected set; }
        public AlgorithmType Algorithm { get; protected set; }

        public BinaryStream(AlgorithmType algo, StreamType type, int blockSize, int keySize, string pass, byte[] salt)
        {
            if (salt == null || salt.Length == 0) { throw new System.ArgumentException("Salt cannot be null or 0 length"); }
            PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(pass, salt);
            byte[] val = pdb.GetBytes(32);
            this.Initialize(algo, type, blockSize, keySize, val, val, CryptoStreamMode.Write);
        }

        public BinaryStream(AlgorithmType algo, StreamType type, int blockSize, int keySize, string pass, byte[] salt, CryptoStreamMode mode)
        {
            if (salt == null || salt.Length == 0) { throw new System.ArgumentException("Salt cannot be null or 0 length"); }
            PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(pass, salt);
            byte[] val = pdb.GetBytes(32);
            this.Initialize(algo, type, blockSize, keySize, val, val, mode);
        }

        public BinaryStream(AlgorithmType algo, StreamType type, int blockSize, int keySize, byte[] key, byte[] iv)
        {
            this.Initialize(algo, type, blockSize, keySize, key, iv, CryptoStreamMode.Write);
        }

        public BinaryStream(AlgorithmType algo, StreamType type, int blockSize, int keySize, byte[] key, byte[] iv, CryptoStreamMode mode)
        {
            this.Initialize(algo, type, blockSize, keySize, key, iv, mode);
        }
        
        public bool CanRead
        {
            get { return this.m_crypto.CanRead; }
        }
        
        public bool CanWrite
        {
            get { return this.m_crypto.CanWrite; }
        }

        public void Close()
        {
            this.m_crypto.Close();
            // TODO: implement the rest of these methods for the stream .. no easy way
            // to achieve this since we're dealing with 2 streams
            //this.m_crypto.BeginRead(
        }

        public void Dispose()
        {
            this.m_crypto.Close();
            this.m_crypto = null;
            this.m_stream = null;
            this.m_algo = null;
        }

        public void Flush()
        {
            this.m_crypto.Flush();
        }

        public int Read(byte[] buffer, int offset, int count)
        {
            return this.m_crypto.Read(buffer, offset, count);
        }

        public int ReadByte()
        {
            return this.m_crypto.ReadByte();
        }

        public void WriteByte(byte value)
        {
            this.m_crypto.WriteByte(value);
        }

        public void Write(byte[] buffer)
        {
            if (buffer == null || buffer.Length == 0) { throw new System.FormatException("Data cannot be null or 0 length"); }
            this.Write(buffer, 0, buffer.Length);
        }

        public void Write(byte[] buffer, int offset, int count)
        {
            if (buffer == null || buffer.Length == 0) { throw new System.FormatException("Data cannot be null or 0 length"); }
            if (offset > buffer.Length) { throw new System.FormatException("Offset must be less than length"); }
            if (count > (buffer.Length - offset)) { throw new System.FormatException("Count must be less than byte count and remaining bytes from offset"); }
            this.m_crypto.Write(buffer, offset, count);
        }

        public byte[] ToArray()
        {
            return this.m_stream.ToArray();
        }

        private void Initialize(AlgorithmType algo, StreamType type, int blockSize, int keySize, byte[] key, byte[] iv, CryptoStreamMode mode)
        {
            if (key == null || key.Length == 0) { throw new System.FormatException("Key cannot be null or 0 length"); }
            if (iv == null || iv.Length == 0) { throw new System.FormatException("Initialization vector cannot be null or 0 length"); }
            this.Type = type;
            this.m_stream = new System.IO.MemoryStream();
            this.InitializeAlgorithm(algo, blockSize, keySize, key, iv);
            this.m_crypto = new CryptoStream(this.m_stream, (type == StreamType.Encrypt ? this.m_algo.CreateEncryptor() : this.m_algo.CreateDecryptor()), mode);
        }

        private void InitializeAlgorithm(AlgorithmType algo, int blockSize, int keySize, byte[] key, byte[] iv)
        {
            this.Algorithm = algo;
            switch (this.Algorithm) {
                case AlgorithmType.AES: this.m_algo = System.Security.Cryptography.Aes.Create(); break;
                case AlgorithmType.AES_Rijndael: this.m_algo = System.Security.Cryptography.Rijndael.Create(); break;
                case AlgorithmType.TripleDES: this.m_algo = System.Security.Cryptography.TripleDES.Create(); break;
                default: throw new System.ArgumentException("Algorithm type unsupported");
            }
            bool foundbs = false;
            foreach (System.Security.Cryptography.KeySizes ks in this.m_algo.LegalBlockSizes) {
                if (blockSize <= ks.MaxSize && blockSize >= ks.MinSize) {
                    foundbs = true; break;
                }
            }
            if (!foundbs) { throw new System.Security.Cryptography.CryptographicException("Illegal block size specified"); }
            if (!this.m_algo.ValidKeySize(keySize)) { throw new System.Security.Cryptography.CryptographicException("Illegal key size specified"); }

            this.m_algo.BlockSize = blockSize;
            this.m_algo.KeySize = keySize;
            this.m_algo.Key = key;
            this.m_algo.IV = iv;
        }
    }
}