Password Protected Stream Using Decorator Pattern

//extends the stream class
public class PasswordProtectedStream : Stream
{
    string password; //password for the stream
    Stream str; //the base stream

    //this is a kind of locking variable so that if read operations are called
    //multiple times, the event (the description to be followed) doesn’t get
    //invoked multiple times
    bool eventRaised = false; 

    //delegate for event
    public delegate void ReadCompleteHandler (object s, ReadCompleteEventArgs e); 

    // event that passes data and read status to the client application
    public event ReadCompleteHandler On_ReadComplete; 

    //set the base parameters
    public PasswordProtectedStream(Stream str, string password)  : base() 
    {
        this.str = str;
        this.password = password;
    }

    #region "Overridden Methods of Stream"
    //override the write method
    public override void Write(byte[] buffer, int offset, int count)
    {
        byte[] data = new byte[count];
        
        for (int i = offset, j = 0; j < count; i++, j++)
            data[j] = buffer[i]; //construct the actual data buffer

        //create an instance of our own custom serialized class (to be followed
        //later)
        DataEnvelop env = new DataEnvelop(data, password); 
        BinaryFormatter f = new BinaryFormatter();
        f.Serialize(str, env); //serialize the object
    }
    
    //override the read method
    public override int Read(byte[] buffer, int offset, int count)
    {
        //read all bytes from base stream
        int r = str.Read(buffer, offset, count);
        
        //construct buffer to hold actual data and not the default buffer
        //otherwise the object won’t be de-serialized properly due to padded empty
        //bytes
        byte[] newData = new byte[str.Length]; 

        //in respect to the actual length of the base stream
        for (int i = 0; i < str.Length; i++) 
            newData[i] = buffer[i]; //copy all non-empty bytes

        //construct memory stream for de-serialization
        MemoryStream mstr = new MemoryStream(newData); 

        BinaryFormatter f = new BinaryFormatter();
        DataEnvelop env = (DataEnvelop)f.Deserialize(mstr);

        if (env.password == password) //if password is matched
        {
            //if event is not empty and it’s not been invoked earlier
            if (On_ReadComplete != null && !eventRaised) 
            {
                On_ReadComplete(this, new ReadCompleteEventArgs (ReadCompleteEventArgs.Status.SUCCESS, env.data)); //bind successful read event

                eventRaised = true; //mark it so that the event is not invoked again on multiple reads
            }
        }
        else //if wrong password
        {
            if (On_ReadComplete != null && !eventRaised) //if event is not empty and it’s not been invoked earlier
            {
                On_ReadComplete(this, new ReadCompleteEventArgs (ReadCompleteEventArgs.Status.FAILURE, null)); //bind un-successful read event

                eventRaised = true; //mark it so that the event is not invoked again on multiple reads
            }
        }

        //return actual number of bytes read and not the bytes of the actual
        //data otherwise it will loop. This is the only reason why I had to pass
        //the data to the event and couldn’t directly process here. If anyone can
        //suggest a way, I would be grateful.
        return r; 
    }

    public override void Close()
    {
        str.Close();
        str.Dispose();
    }
    #endregion

    #region "Overridden Properties of Stream"
    public override void SetLength(long value)
    {
        str.SetLength(value);
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        return str.Seek(offset, origin);
    }

    public override long Position
    {
        get { return str.Position; }
        set { str.Position = value; }
    }

    public override long Length
    {
        get { return str.Length; }
    }

    public override bool CanWrite
    {
        get { return str.CanWrite; }
    }

    public override void Flush()
    {
        str.Flush();
    }

    public override bool CanSeek
    {
        get { return str.CanSeek; }
    }

    public override bool CanRead
    {
        get { return str.CanRead; }
    }

    #endregion

    //private DataEnvelop Class that is serialized to the base stream with the
    //password and the data bytes, it can be enhanced to encrypt the password
    [Serializable]
    class DataEnvelop 
    {
        public byte[] data { get; set; }
        public string password { get; set; }
        
        public DataEnvelop(byte[] data, string password)
        {
            this.data = data;
            this.password = password;
        }
    }
    
    //arguments passed to the event that passes data to the client
    public class ReadCompleteEventArgs : EventArgs
    {
        byte[] data; //actually data bytes
        
        //status of the current output, whether password is correct or not
        Status status;
    
        //if password is correct, set as CORRECT else FAILURE
        public enum Status { SUCCESS, FAILURE }
    
        public ReadCompleteEventArgs(Status status, byte[] data)
        {
            this.data = data;
            this.status = status;
        }
        
        public byte[] Data { get { return data; } }
        public Status ReadStatus { get { return status; } }
    }
}

//This is the client code. You can place two buttons named button1 and button2 and
//place the following code in the forms code section
private void button1_Click(object sender, EventArgs e)
{
    PasswordProtectedStream st = new PasswordProtectedStream
    (new FileStream("C:/pwdsample.txt", FileMode.Create), "12345"); //create instance of our stream
    
    StreamWriter w = new StreamWriter(st);
    w.Write("Hye this is test"); //write some data
    w.Flush();
    w.Close();
    st.Close();
    st.Dispose();
    MessageBox.Show("Data Written Successfully");
}

private void button2_Click(object sender, EventArgs e)
{
    //create instance of our stream, try changing a password here
    PasswordProtectedStream st = new PasswordProtectedStream(new FileStream ("C:/pwdsample.txt", FileMode.Open), "12345");
    
    st.On_ReadComplete += new PasswordProtectedStream.ReadCompleteHandler (st_On_ReadComplete); //hook the read complete event
    
    StreamReader w = new StreamReader(st);
    
    //Read but don’t display the data here, else you won’t get anything useful.
    //Readers are welcome if they can provide an implementation which enables us
    //to read the data in usual manner, without the use of event
    w.ReadToEnd();
    
    w.Close();
    st.Close();
    st.Dispose();
}

void st_On_ReadComplete (object s, PasswordProtectedStream.ReadCompleteEventArgs e)
{
    if (e.ReadStatus == PasswordProtectedStream.ReadCompleteEventArgs.Status.FAILURE) //if wrong password

        MessageBox.Show("Wrong Password");
    else
        MessageBox.Show("Data Read back: " + Encoding.ASCII.GetString(e.Data)); //display data
}