C#

1) Load an asymmetric algorithm (RSACryptoServiceProvider) stored using a CspParameters object
2) Create a symmetric algorithm object (AesCryptoServiceProvider)
3) Encrypt the concatenated key and initialization vector using the RSA encryptor
4) Create a new MemoryStream object (with associated BinaryWriter)
5) Write the following data to the output stream:
   *The size of the encrypted key/IV vector
   *The encrypted key/IV vector
6) Create new CryptoStream and BinaryWriter objects and write my data to the MemoryStream
7) Hash the MemoryStream, and sign the hash
8) Open a file for writing (FileStream)
9) Write the following data
   *Length of the signed hash
   *The signed hash
   *COPY THE CONTENTS OF THE MEMORY STREAM TO THE OUTPUT

class ExampleForm : Form {
    private readonly int                      m_SymmetricKeySize = s_KeySizeSym >> 3;
    private readonly int                      m_SymmetricBlockSize;
    private readonly RSACryptoServiceProvider m_AsymmetricAlg;
    private readonly SymmetricAlgorithm       m_SymmetricAlg = new AesCryptoServiceProvider();
    private readonly HashAlgorithm            m_HashAlg      = new MD5CryptoServiceProvider();
    private readonly string                   m_OutFile      =
        Path.Combine(Application.CommonAppDataPath, "Example.dat");

    private static void CopyStream(Stream src, Stream dst) {
        const int bufferSize = 256;
        byte[]    buffer     = new byte[bufferSize];
        int count;
        do {
            count = src.Read(buffer, 0, bufferSize);
            dst.Write(buffer, 0, count);
        } while (count == bufferSize);
    }

    public ExampleForm() {
        // Create the cryptographic data members
        m_SymmetricBlockSize   = m_SymmetricAlg.BlockSize >> 3;
        CspParameters csp      = new CspParameters();
        csp.KeyContainerName   = "Example Container";
        m_AsymmetricAlg        = new RSACryptoServiceProvider(2048, csp);

        // Load the encrypted file
        bool isFileValid = File.Exists(m_OutFile);
        if (isFileValid) {
            // Open the input file, and create a temporary memory stream
            Stream       dataStream   = new MemoryStream();
            Stream       fileStream   = File.OpenRead(m_OutFile);
            BinaryReader binaryReader = new BinaryReader(fileStream);

            // Read the signature
            byte[] sign = new byte[binaryReader.ReadInt32()];
            fileStream.Read(sign, 0, sign.Length);

            // Copy the remaining contents to another stream
            ExampleForm.CopyStream(fileStream, dataStream);

            // Close the input file
            binaryReader.Close();
            fileStream  .Close();

            // Compute and verify the hash value of the new stream
            byte[] hash = m_HashAlg.ComputeHash(dataStream);
            isFileValid = m_AsymmetricAlg.VerifyHash(hash,
                          CryptoConfig.MapNameToOID("MD5"), sign);

            if (isFileValid) {
                // Create the necessary input streams
                dataStream.Seek(0, SeekOrigin.Begin);
                binaryReader = new BinaryReader(dataStream);

                // Load the key and IV vectors
                byte[] encKeyIV = new byte[binaryReader.ReadInt32()];
                dataStream.Read(encKeyIV, 0, encKeyIV.Length);
                byte[] keyAndIV = new byte[m_SymmetricBlockSize + m_SymmetricKeySize];
                keyAndIV = m_AsymmetricAlg.Decrypt(encKeyIV, true);

                // Copy the key and IV to the symmetric algorithm members
                byte[] key = new byte[m_SymmetricKeySize  ];
                byte[] iv  = new byte[m_SymmetricBlockSize];
                for (int idx = 0; idx < m_SymmetricKeySize; ++idx)
                    key[idx] = keyAndIV[idx];
                for (int idx = 0; idx < m_SymmetricBlockSize; ++idx)
                    iv [idx] = keyAndIV[idx + m_SymmetricKeySize];

                // Create the streams for outputting data
                CryptoStream cryptoStream = new CryptoStream(dataStream,
                    m_SymmetricAlg.CreateDecryptor(key, iv), CryptoStreamMode.Read);
                BinaryReader cryptoReader = new BinaryReader(cryptoStream);

                // Read the data, utilizing...
                //   cryptoReader.ReadUInt32();
                //   cryptoReader.ReadString();
                //   cryptoReader.ReadInt64 ();

                // Close the appropriate data streams
                binaryReader.Close();
                cryptoReader.Close();
                cryptoStream.Close();
            } else {
                // The file is corrupt
            }

            // Close the data stream
            dataStream.Close();
        }
    }

    private void ExampleForm_FormClosing(object sender, FormClosingEventArgs e) {
        // Create an array containing the symmetric key and initialization vector
        byte[] keyAndIV = new byte[m_SymmetricBlockSize + m_SymmetricKeySize];
        m_SymmetricAlg.Key.CopyTo(keyAndIV, 0);
        m_SymmetricAlg.IV .CopyTo(keyAndIV, m_SymmetricKeySize);

        // Create the temporary output objects
        Stream       dataStream   = new MemoryStream();
        BinaryWriter binaryWriter = new BinaryWriter(dataStream);
        BinaryWriter cryptoWriter = new BinaryWriter(new CryptoStream(
            dataStream, m_SymmetricAlg.CreateEncryptor(), CryptoStreamMode.Write));

        // Encrypt and write the symmetric key and IV using the asymmetric algorithm
        byte[] encKeyIV = m_AsymmetricAlg.Encrypt(keyAndIV, true);
        binaryWriter.Write(encKeyIV.Length);
        binaryWriter.Flush();
        dataStream.Write(encKeyIV, 0, encKeyIV.Length);


        // Encrypt and write the data utilizing...
        //     cryptoWriter.Write(uint);
        //     cryptoWriter.Write(string);
        //     cryptoWriter.Write(long);
        cryptoWriter.Flush();

        // Compute and sign the hash code for the file
        byte[] hash = m_HashAlg.ComputeHash(dataStream);
        byte[] sign = m_AsymmetricAlg.SignHash(hash, CryptoConfig.MapNameToOID(s_HashName));

#region Option 1 (What I would like to do)
        Stream fileStream = File.OpenWrite(m_OutFile);
        binaryWriter = new BinaryWriter(fileStream);

        // Write the data to the output file
        binaryWriter.Write(sign.Length);
        binaryWriter.Flush();
        fileStream.Write(sign, 0, sign.Length);
        dataStream.Seek(0, SeekOrigin.Begin);
        ExampleForm.CopyStream(dataStream, fileStream);

        // Close the streams
        cryptoWriter.Close();
        binaryWriter.Close();
        fileStream.Close();
        dataStream.Close();
#endregion

#region Option 2 (The option that currently works)
        // Close the streams
        cryptoWriter.Close();
        binaryWriter.Close();
        dataStream  .Close();

        // Create the actual output objects
        Stream fileStream = File.OpenWrite(m_OutFile);
        binaryWriter = new BinaryWriter(fileStream);
        cryptoWriter = new BinaryWriter(new CryptoStream(
            fileStream, m_SymmetricAlg.CreateEncryptor(), CryptoStreamMode.Write));

        // Write the data to the output file
        binaryWriter.Write(sign.Length);
        binaryWriter.Flush();
        fileStream.Write(sign, 0, sign.Length);

        // Rewrite the data already written to the output stream
        binaryWriter.Write(encKeyIV.Length);
        binaryWriter.Flush();
        fileStream.Write(encKeyIV, 0, encKeyIV.Length);

        // Encrypt and write the data utilizing...
        //     cryptoWriter.Write(uint);
        //     cryptoWriter.Write(string);
        //     cryptoWriter.Write(long);

        // Close the output objects
        cryptoWriter.Close();
        binaryWriter.Close();
        fileStream  .Close();
#endregion

    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Collections;

namespace KPlayer
{
    public partial class Form1 : Form
    {
        WMPLib.WindowsMediaPlayer wmp = new WMPLib.WindowsMediaPlayer();
        WMPLib.IWMPPlaylist pl;
        //WMPLib.IWMPPlaylistArray plItems; 
        WMPLib.IWMPMedia media;

        // Required designer variable
        //private System.ComponentModel.Container components = null;

        ArrayList ar = new ArrayList();
        int intCount = 0;      
        List<int> numbers = new List<int>();
      
        float currentSize = 10;
        string currentFont = "DS-Digital";

        public Form1()
        {
            // Required for Windows Form Designer support
            InitializeComponent();
        }
       
        [STAThread]
        // Declare Windows API calls used to access Windows hooks
        [DllImport("user32.dll")]

        public static extern int SetWindowsHookEx(int hookType,
                                                   HookProc callback,
                                                   int instance,
                                                   int threadID);
        [DllImport("user32.dll")]
        public static extern int CallNextHookEx(int hookHandle, int code,
                                                int wparam, int lparam);
        [DllImport("user32.dll")]
        public static extern bool UnhookWindowsHookEx(int hookHandle);
        [DllImport("user32.dll")]
        public static extern int GetKeyState(int vKey);

        // Fields, constants, and structures used by the keyboard hook.
        int hookHandle = 0;
        HookProc cb = null;

        public const int WH_KEYBOARD = 2;

        public const int HC_ACTION = 0;
        public const int HC_NOREMOVE = 3;

        public const int VK_CONTROL = 0x11;
        public const int VK_LWIN = 0x5B;
        public const int VK_RWIN = 0x5C;
        public const int VK_APPS = 0x5D;
        public const int VK_LSHIFT = 0xA0;
        public const int VK_RSHIFT = 0xA1;
        public const int VK_LCONTROL = 0xA2;
        public const int VK_RCONTROL = 0xA3;
        public const int VK_LMENU = 0xA4;
        public const int VK_RMENU = 0xA5;
        public const int VK_BROWSER_BACK = 0xA6;
        public const int VK_BROWSER_FORWARD = 0xA7;
        public const int VK_BROWSER_REFRESH = 0xA8;
        public const int VK_BROWSER_STOP = 0xA9;
        public const int VK_BROWSER_SEARCH = 0xAA;
        public const int VK_VOLUME_MUTE = 0xAD;
        public const int VK_VOLUME_DOWN = 0xAE;
        public const int VK_VOLUME_UP = 0xAF;
        public const int VK_MEDIA_NEXT_TRACK = 0xB0;
        public const int VK_MEDIA_PREV_TRACK = 0xB1;
        public const int VK_MEDIA_STOP = 0xB2;
        public const int VK_MEDIA_PLAY_PAUSE = 0xB3;
        public const int KF_UP = 0x8000;
        public const long KB_TRANSITION_FLAG = 0x80000000;
        public const int VK_W = 0x57;

        // Keyboard hook delegate
        public delegate int HookProc(int code, int wparam, int lparam);
        public int Proc(int code, int wparam, int lparam)
        {
            if (code == HC_ACTION)
            {
                switch (wparam)
                {
                    case VK_BROWSER_BACK:
                        // Handle Back keyboard button here.
                        textBox1.Text += "Browser Back key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_BROWSER_FORWARD:
                        // Handle Forward keyboard button here.
                        textBox1.Text += "Browser Forward key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_BROWSER_REFRESH:
                        // Handle Refresh keyboard button here.
                        textBox1.Text += "Browser Refresh key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_BROWSER_STOP:
                        // Handle Stop keyboard button here.
                        textBox1.Text += "Browser Stop key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_BROWSER_SEARCH:
                        // Handle Search keyboard button here.
                        textBox1.Text += "Browser Search key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_VOLUME_MUTE:
                        // Handle Mute keyboard button here.
                        textBox1.Text += "Volume Mute key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_VOLUME_DOWN:
                        // Handle Volume - keyboard button here.
                        textBox1.Text += "Volume Down key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_VOLUME_UP:
                        // Handle Volume + keyboard button here.
                        textBox1.Text += "Volume Up key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_MEDIA_NEXT_TRACK:
                        // Handle Next Track keyboard button here.
                        textBox1.Text += "Media Next Track key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_MEDIA_PREV_TRACK:
                        // Handle Previous Track keyboard button here.
                        textBox1.Text += "Media Previous Track key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_MEDIA_STOP:
                        // Handle Stop keyboard button here.
                        textBox1.Text += "Media Stop key caught" +
                                         Environment.NewLine;
                        break;
                    case VK_MEDIA_PLAY_PAUSE:
                        // Handle PLAY keyboard button here.
                        textBox1.Text += "Media Play/Pause key caught" +
                                         Environment.NewLine;
                        break;
                }
            }
            return (CallNextHookEx(hookHandle, code, wparam, lparam));
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            wmp.PlayStateChange +=
                new WMPLib._WMPOCXEvents_PlayStateChangeEventHandler(Player_PlayStateChange);
            wmp.MediaError +=
                new WMPLib._WMPOCXEvents_MediaErrorEventHandler(Player_MediaError);

                   }