Encryption/Decryption with .NET

'' read out the result from the Crypto Stream
Dim sr As System.IO.StreamReader = New ystem.IO.StreamReader(cs)
Return sr.ReadToEnd() ***This line has the error***
End Function

[CryptographicException: Bad Data.]
   System.Security.Cryptography.CryptoAPITransform._DecryptData(IntPtr hKey, 
                            Byte[] rgb, Int32 ib, Int32 cb, Boolean fDone) +0
   System.Security.Cryptography.CryptoAPITransform.TransformFinalBlock(
                 Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount) +1007
   System.Security.Cryptography.CryptoStream.Read(Byte[] buffer, Int32 offset,
                 Int32 count) +802
   System.IO.StreamReader.ReadBuffer(Char[] userBuffer, Int32 userOffset, 
                 Int32 desiredChars, Boolean& readToUserBuffer) +68
   System.IO.StreamReader.Read(Char[] buffer, Int32 index, Int32 count) +125
   System.IO.StreamReader.ReadToEnd() +93
   SecurIt.Crypto.SymmCrypto.Decrypting(String Source, String Key) in 
           C:\ATEC System.root\ATEC System\SecurityLayer\UserSecurity.vb:141

Private Sub btnRunTest_Click(ByVal sender As System.Object, 
                          ByVal e As System.EventArgs) Handles btnRunTest.Click
        Dim objCrypto As SymmCrypto = New SymmCrypto
        Dim countBad As Integer = 0
        Dim countGood As Integer = 0
        Dim sPswd As String 'ASCII char
        Dim pswdLength As Integer
        Dim tmpString1, tmpString2 As String

        Dim i, j As Integer

        Dim rand As New Random(CInt(Date.Now.Ticks And Integer.MaxValue))

        txtRunTest.Text = ""

        For i = 1 To txtHowMany.Text
            sPswd = ""
            'get password length between 1 and 30
            pswdLength = rand.Next(1, 30)
            'build password string by selecting random Ascii
            'characters between "0" and "z"
            For j = 1 To pswdLength
                sPswd &= Chr(rand.Next(48, 122))
            Next

            'Get a random key between 1 and 1M 
            Key = rand.Next(1, 1000000).ToString

            objCrypto.SymmCrypto(SymmCrypto.SymmProvEnum.RC2)
            tmpString1 = objCrypto.Encrypting(sPswd, Key)
            tmpString2 = objCrypto.Decrypting(tmpString1, Key)

            If tmpString2.Equals(sPswd) Then
                countGood += 1
            Else
                countBad += 1
            End If

        Next

      txtRunTest.Text = "Test Complete. Good=" & countGood.ToString & _
            " Bad=" & countBad.ToString

    End Sub

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

namespace FangHome_Crypto
{
   /// <summary>
   /// SymmCrypto is a wrapper of System.Security.Cryptography.SymmetricAlgorithm classes
   /// and simplifies the interface. It supports customized SymmetricAlgorithm as well.
   /// </summary>
   public class SymmCrypto
   {
      /// <remarks>
      /// Supported .Net intrinsic SymmetricAlgorithm classes.
      /// </remarks>
      public enum SymmProvEnum : int
      {
         DES, RC2, Rijndael, TripleDES
      }

      private SymmetricAlgorithm mobjCryptoService;

      /// <remarks>
      /// Constructor for using an intrinsic .Net SymmetricAlgorithm class.
      /// </remarks>
      public SymmCrypto(SymmProvEnum NetSelected)
      {
         switch (NetSelected)
         {
            case SymmProvEnum.DES:
               mobjCryptoService = new DESCryptoServiceProvider();
               break;
            case SymmProvEnum.RC2:
               mobjCryptoService = new RC2CryptoServiceProvider();
               break;
            case SymmProvEnum.Rijndael:
               mobjCryptoService = new RijndaelManaged();
               break;
            case SymmProvEnum.TripleDES:
               mobjCryptoService = new TripleDESCryptoServiceProvider();
               break;
         }
      }

      /// <remarks>
      /// Constructor for using a customized SymmetricAlgorithm class.
      /// </remarks>
      public SymmCrypto(SymmetricAlgorithm ServiceProvider)
      {
         mobjCryptoService = ServiceProvider;
      }

      private byte[] GetLegalKey(string Key)
      {
         string sTemp = Key;
         mobjCryptoService.GenerateKey();
         byte[] bytTemp = mobjCryptoService.Key;
         int KeyLength = bytTemp.Length;
         if (sTemp.Length > KeyLength)
            sTemp = sTemp.Substring(0, KeyLength);
         else if (sTemp.Length < KeyLength)
            sTemp = sTemp.PadRight(KeyLength, ' ');

         return ASCIIEncoding.ASCII.GetBytes(sTemp);
      }

      private byte[] GetLegalIV()
      {
         // The initial string of IV may be modified with any data you like
         string sTemp = "救臆妲饣";
         mobjCryptoService.GenerateIV();
         byte[] bytTemp = mobjCryptoService.IV;
         int IVLength = bytTemp.Length;
         if (sTemp.Length > IVLength)
            sTemp = sTemp.Substring(0, IVLength);
         else if (sTemp.Length < IVLength)
            sTemp = sTemp.PadRight(IVLength, ' ');

         return ASCIIEncoding.ASCII.GetBytes(sTemp);
      }

      public string Encrypting(string Source, string Key)
      {
         // use UTF8 unicode conversion for two byte characters
         byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);

         // create a MemoryStream so that the process can be done without I/O files
         System.IO.MemoryStream ms = new System.IO.MemoryStream();

         // set the private key
         mobjCryptoService.Key = GetLegalKey(Key);
         mobjCryptoService.IV = GetLegalIV();

         // create an Encryptor from the Provider Service instance
         ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();

         // create Crypto Stream that transforms a stream using the encryption
         CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);

         // write out encrypted content into MemoryStream
         cs.Write(bytIn, 0, bytIn.Length);
         cs.FlushFinalBlock();

         ms.Close();
         byte[] bytOut = ms.ToArray();

         // convert into Base64 so that the result can be used in xml
         return System.Convert.ToBase64String(bytOut);
      }

      public string Decrypting(string Source, string Key)
      {
         // convert from Base64 to binary
         byte[] bytIn = System.Convert.FromBase64String(Source);
         // create a MemoryStream with the input
         System.IO.MemoryStream ms = new System.IO.MemoryStream(bytIn, 0, bytIn.Length);

         // set the private key
         mobjCryptoService.Key = GetLegalKey(Key);
         mobjCryptoService.IV = GetLegalIV();

         // create a Decryptor from the Provider Service instance
         ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();

         // create Crypto Stream that transforms a stream using the decryption
         CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);

         // read out the result from the Crypto Stream
         System.IO.StreamReader sr = new System.IO.StreamReader( cs );
         return sr.ReadToEnd();
      }
   }
}