CryptoStream returns bad data only on some machines

[dxterra]

I have an application that uses CryptoStream to encrypt and decrypt
strings and stores and retrieves these values from a SQLServer
database.

When I run the application on my machine I can decrypt all the strings
in the database. When I run from a server I get "Bad Data" errors when
I try to close my CryptoStream.

Here is a sample application that I threw together:

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

namespace myTest
{
class Program
{
private static byte[] byteToken;

static void Main( string[] args )
{
Console.WriteLine( "Decoding sample string:" );

string testtoken = "mGAETZOUuW5tjFR4ihp80D23JQg4Uhtfdq
+UjZlBOE9XIRVvi+FtKg3R7TygdTEOjG+Qj6SLXl24fng+vuubLzK1vX1igECVQV
+9KKDjWpSG82S
+GTVOMsButxrae1bN83XdcFV0TN82iBW3Er4fKFfYSgAwyNEDCtrKO1hbbInLD0Z5ktzNB
+pfU4JVOVKAUbSPjIt4/8Na8HJimxleF6q/0SmRL0EOiyJRMT1xrKSHBK2VY/
rJnMicl053U+J1ZDGcHbUBPY1Z+
+dd0cfgKD79t6N0QJLzyPeuRVjmobT6lxznalAxgp5g0IXQugsMHuWeBR/zl/yey/
+h5dHPoK5XRGs56F+P";

Console.WriteLine( DecryptDES( testtoken ) );

Console.WriteLine( "Creating new string:" );

string tmpToken = EncryptDES( RandomString( 64, 64 ) );

Console.WriteLine( tmpToken );

Console.WriteLine( "Decoding new string:" );

Console.WriteLine( DecryptDES( tmpToken ) );
}


#region Encryption Methods
private static string RandomToken()
{
byte[] randombytes = new byte[128];

RNGCryptoServiceProvider Gen = new RNGCryptoServiceProvider
();
Gen.GetBytes( randombytes );
byteToken = randombytes;

return Encoding.Unicode.GetString( randombytes );
}

public static string RandomString( int minLength, int
maxLength )
{

string PASSWORD_CHARS_LCASE = "abcdefgijkmnopqrstwxyz";
string PASSWORD_CHARS_UCASE = "ABCDEFGHJKLMNPQRSTWXYZ";
string PASSWORD_CHARS_NUMERIC = "123456789";
string PASSWORD_CHARS_SPECIAL = "*$-+?_&=!{}";

// Create a local array containing supported password
characters
// grouped by types. You can remove character groups from
this
// array, but doing so will weaken the password strength.
char[][] charGroups = new char[][]
{
PASSWORD_CHARS_LCASE.ToCharArray(),
PASSWORD_CHARS_UCASE.ToCharArray(),
PASSWORD_CHARS_NUMERIC.ToCharArray(),
PASSWORD_CHARS_SPECIAL.ToCharArray()
};

// Use this array to track the number of unused characters
in each
// character group.
int[] charsLeftInGroup = new int[charGroups.Length];

// Initially, all characters in each group are not used.
for( int i = 0; i < charsLeftInGroup.Length; i++ )
charsLeftInGroup[i] = charGroups[i].Length;

// Use this array to track (iterate through) unused
character groups.
int[] leftGroupsOrder = new int[charGroups.Length];

// Initially, all character groups are not used.
for( int i = 0; i < leftGroupsOrder.Length; i++ )
leftGroupsOrder[i] = i;

// Because we cannot use the default randomizer, which is
based on the
// current time (it will produce the same "random" number
within a
// second), we will use a random number generator to seed
the
// randomizer.

// Use a 4-byte array to fill it with random bytes and
convert it then
// to an integer value.
byte[] randomBytes = new byte[4];

// Generate 4 random bytes.
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider
();
rng.GetBytes( randomBytes );

// Convert 4 bytes into a 32-bit integer value.
int seed = ( randomBytes[0] & 0x7f ) << 24 |
randomBytes[1] << 16 |
randomBytes[2] << 8 |
randomBytes[3];

// Now, this is real randomization.
Random random = new Random( seed );
// This array will hold password characters.
char[] password = null;
// Allocate appropriate memory for the password.
if( minLength < maxLength )
password = new char[random.Next( minLength, maxLength
+ 1 )];
else
password = new char[minLength];

// Index of the next character to be added to password.
int nextCharIdx;
// Index of the next character group to be processed.
int nextGroupIdx;
// Index which will be used to track not processed
character groups.
int nextLeftGroupsOrderIdx;
// Index of the last non-processed character in a group.
int lastCharIdx;
// Index of the last non-processed group.
int lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;

// Generate password characters one at a time.
for( int i = 0; i < password.Length; i++ )
{
// If only one character group remained unprocessed,
process it;
// otherwise, pick a random character group from the
unprocessed
// group list. To allow a special character to appear
in the
// first position, increment the second parameter of
the Next
// function call by one, i.e. lastLeftGroupsOrderIdx +
1.
if( lastLeftGroupsOrderIdx == 0 )
nextLeftGroupsOrderIdx = 0;
else
nextLeftGroupsOrderIdx = random.Next( 0,
lastLeftGroupsOrderIdx );

// Get the actual index of the character group, from
which we will
// pick the next character.
nextGroupIdx = leftGroupsOrder
[nextLeftGroupsOrderIdx];
// Get the index of the last unprocessed characters in
this group.
lastCharIdx = charsLeftInGroup[nextGroupIdx] - 1;
// If only one unprocessed character is left, pick it;
otherwise,
// get a random character from the unused character
list.
if( lastCharIdx == 0 )
nextCharIdx = 0;
else
nextCharIdx = random.Next( 0, lastCharIdx + 1 );

// Add this character to the password.
password[i] = charGroups[nextGroupIdx][nextCharIdx];

// If we processed the last character in this group,
start over.
if( lastCharIdx == 0 )
charsLeftInGroup[nextGroupIdx] = charGroups
[nextGroupIdx].Length;
// There are more unprocessed characters left.
else
{
// Swap processed character with the last
unprocessed character
// so that we don't pick it until we process all
characters in
// this group.
if( lastCharIdx != nextCharIdx )
{
char temp = charGroups[nextGroupIdx]
[lastCharIdx];
charGroups[nextGroupIdx][lastCharIdx] =
charGroups[nextGroupIdx][nextCharIdx];
charGroups[nextGroupIdx][nextCharIdx] = temp;
}
// Decrement the number of unprocessed characters
in
// this group.
charsLeftInGroup[nextGroupIdx]--;
}

// If we processed the last group, start all over.
if( lastLeftGroupsOrderIdx == 0 )
lastLeftGroupsOrderIdx = leftGroupsOrder.Length -
1;
// There are more unprocessed groups left.
else
{
// Swap processed group with the last unprocessed
group
// so that we don't pick it until we process all
groups.
if( lastLeftGroupsOrderIdx !=
nextLeftGroupsOrderIdx )
{
int temp = leftGroupsOrder
[lastLeftGroupsOrderIdx];
leftGroupsOrder[lastLeftGroupsOrderIdx] =
leftGroupsOrder[nextLeftGroupsOrderIdx];
leftGroupsOrder[nextLeftGroupsOrderIdx] =
temp;
}
// Decrement the number of unprocessed groups.
lastLeftGroupsOrderIdx--;
}
}
// Convert password characters into a string and return
the result.
return new string( password );

}

public static byte[] EncryptDES( byte[] clearData, byte[] Key,
byte[] IV )
{

MemoryStream ms = new MemoryStream();

TripleDES tripDES = TripleDES.Create();

tripDES.Key = Key;
tripDES.IV = IV;

CryptoStream cs = new CryptoStream( ms,
tripDES.CreateEncryptor(), CryptoStreamMode.Write );

cs.Write( clearData, 0, clearData.Length );

cs.Close();
ms.Close();

byte[] encryptedData = ms.ToArray();

byte[] testbyte = new byte[byteToken.Length +
encryptedData.Length];
byteToken.CopyTo( testbyte, 0 );
encryptedData.CopyTo( testbyte, byteToken.Length );


return testbyte;
}

public static string EncryptDES( string clearText )
{

byte[] clearBytes = Encoding.Unicode.GetBytes
( clearText );

Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes
( RandomToken(),
new byte[] { 0xe3, 0xe4, 0xed, 0x43, 0x6e, 0x74, 0x72,
0x61, 0x2e, 0x6d, 0x65, 0x6c,
0x4c, 0x6f, 0x6e, 0x62, 0x41, 0x4e,
0x6b, 0x2e, 0x43,
0x6f, 0x6d, 0x5c, 0x52, 0x50, 0x4e,
0x73, 0x53, 0xe3, 0xe4, 0xed} );

byte[] encryptedData = EncryptDES( clearBytes, pdb.GetBytes
( 24 ), pdb.GetBytes( 8 ) );

return Convert.ToBase64String( encryptedData );
}
#endregion


#region Decryption Methods

private static byte[] DecryptDES( byte[] cipherData, byte[]
Key, byte[] IV )
{
MemoryStream ms = new MemoryStream();

TripleDES tripDES = TripleDES.Create();

tripDES.Key = Key;
tripDES.IV = IV;

CryptoStream cs = new CryptoStream( ms,
tripDES.CreateDecryptor(), CryptoStreamMode.Write );
cs.Write( cipherData, 0, cipherData.Length );
cs.FlushFinalBlock();
cs.Close();
ms.Flush();
ms.Close();

byte[] decryptedData = ms.ToArray();
return decryptedData;
}

public static string DecryptDES( string cipherText )
{
//string ErrorText = "Error: ";
byte[] cipherBytes;
try
{
try
{
cipherBytes = Convert.FromBase64String
( cipherText );
}
catch
{
throw new FormatException();
}
byte[] rmk = new byte[128];
byte[] cipher = new byte[cipherBytes.Length - 128];

int i = 0;
for( i = 0; i < 128; i++ )
{
rmk[i] = cipherBytes[i];
}

int j = 0;
for( i = 0; i < ( cipherBytes.Length - 128 ); i++ )
{
cipher[j] = cipherBytes[i + 128];
j++;
}

Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes
( System.Text.Encoding.Unicode.GetString( rmk ),
new byte[] { 0xe3, 0xe4, 0xed, 0x43, 0x6e, 0x74,
0x72, 0x61, 0x2e, 0x6d, 0x65, 0x6c,
0x4c, 0x6f, 0x6e, 0x62, 0x41, 0x4e,
0x6b, 0x2e, 0x43,
0x6f, 0x6d, 0x5c, 0x52, 0x50, 0x4e,
0x73, 0x53, 0xe3, 0xe4, 0xed} );

byte[] decryptedData = DecryptDES( cipher, pdb.GetBytes
( 24 ), pdb.GetBytes( 8 ) );

return Encoding.Unicode.GetString( decryptedData );
}
catch( Exception e )
{
throw new Exception( e.ToString() );
}
}
#endregion

}
}



Any help would be appreciated. Thanks.

[dxterra]