Initial Commit
This commit is contained in:
875
TomcatServer/CrossProduct.Core/PerSeCryptography.cs
Normal file
875
TomcatServer/CrossProduct.Core/PerSeCryptography.cs
Normal file
@@ -0,0 +1,875 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Security.Cryptography;
|
||||
using System.IO;
|
||||
//using System.Windows.Forms;
|
||||
using System.Collections.ObjectModel;
|
||||
|
||||
namespace CrossProduct.Core
|
||||
{
|
||||
/// <summary>
|
||||
/// Text Encryption Types that are Supported by the PerSeCryptography class.
|
||||
/// </summary>
|
||||
internal enum PerSeTextEncryptionTypes
|
||||
{
|
||||
Code,
|
||||
Filename,
|
||||
Text
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The PerSeCryptography class contains functionality to perform
|
||||
/// custom PerSe cryptography routines
|
||||
/// </summary>
|
||||
public class PerSeCryptography
|
||||
{
|
||||
#region Member Variables
|
||||
private const string KeyEncryptionString = "7:i#t~<Tm*I{cC1-+AygowsP}Zeb,WRp5^k?>QzV_BMF4u3!" +
|
||||
"XH;/)=(8dhEUnD.OJ6%0@G2&rNfqSv\\ja[LxYK$]l9";
|
||||
private const string ValidCodeCharacters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||||
private const string ValidFilenameCharacters = "!#$%&'()-0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +
|
||||
"^_`{}~ƒ¡¢£¥ª°±²µ·º»¼½¿ÄÅÆÇÉÑÖÜß÷";
|
||||
private const string ValidTextCharacters = "!#$%&()-0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" +
|
||||
"^_`{}~ƒ¡¢£¥ª°±²µ·º»¼½¿ÄÅÆÇÉÑÖÜß÷ ;:\",.*/\\<>?|+=";
|
||||
|
||||
private const int KeyStringLength = 5;
|
||||
private const int MaxExtraEncryptionCharacters = 7;
|
||||
private const int SplitKeyIndex = 4;
|
||||
private const int InvalidStringCharacters = 50;
|
||||
private const int EncryptionKeyBitMask = 15;
|
||||
private const int EncryptionKeyShift = 4;
|
||||
private const int EncryptionKeyMaxUnchangedCount = 10;
|
||||
private const int EncryptionKeySkipKeys = 5;
|
||||
private const int EncryptionKeySeed = 32767;
|
||||
private const int RandomNumberBitMask = 65535;
|
||||
private const int RandomNumberMultiplier = 17405;
|
||||
private const int RandomNumberExtraValue = 196;
|
||||
private const float RandomNumberDivisor = 65536.0f;
|
||||
|
||||
private int _currentRandomNumber;
|
||||
private Random _randomNumGen;
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="PerSeCryptography"/> class.
|
||||
/// </summary>
|
||||
/// Change Made On: 6/23/2009
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
public PerSeCryptography()
|
||||
{
|
||||
_randomNumGen = new Random();
|
||||
_currentRandomNumber = _randomNumGen.Next() & RandomNumberBitMask;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts a String with an Embedded Key
|
||||
/// </summary>
|
||||
/// <param name="encryptedText">encrypted text string to decrypt</param>
|
||||
/// <returns>the decrypted text string</returns>
|
||||
public string DecryptText(string encryptedText)
|
||||
{
|
||||
return Decrypt(encryptedText, PerSeTextEncryptionTypes.Text);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts a Text string using a key
|
||||
/// </summary>
|
||||
/// <param name="encryptedText">text string to decrypt</param>
|
||||
/// <param name="key">key to use to decrypt the string</param>
|
||||
/// <returns>decrypted text</returns>
|
||||
public string DecryptText(string encryptedText, int key)
|
||||
{
|
||||
return Decrypt(encryptedText, key, PerSeTextEncryptionTypes.Text);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts a String to Binary
|
||||
/// </summary>
|
||||
/// <param name="decryptedText">text to encrypt</param>
|
||||
/// <returns>encrypted text</returns>
|
||||
public string EncryptBinaryString(string decryptedText)
|
||||
{
|
||||
try
|
||||
{
|
||||
return DataEncryption.EncryptString(decryptedText);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error Encrypting binary String", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts a text string from binary to text
|
||||
/// </summary>
|
||||
/// <param name="encryptedText">The encrypted text.</param>
|
||||
/// <returns>decrypted text</returns>
|
||||
public string DecryptBinaryString(string encryptedText)
|
||||
{
|
||||
try
|
||||
{
|
||||
return DataEncryption.DecryptString(encryptedText);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error Decrypting Binary String", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts a Text string using a key and industry standard encryption modes - Rijndael will be default which is the same as AES 256 bit encryption.
|
||||
/// </summary>
|
||||
/// <param name="text">text string to encrypt</param>
|
||||
/// <param name="key">key to use to encrypt the string</param>
|
||||
/// <param name="encryptionMode">Mode of encryption of choice - "DES" or "RC2" or "Rijndael" or "TripleDES" - Default will be "Rijndael"</param>
|
||||
/// <returns>the text encrypted</returns>
|
||||
public string EncryptText(string text, string key, string encryptionMode)
|
||||
{
|
||||
byte[] encryptedData = Encrypt(text, key, encryptionMode);
|
||||
return Convert.ToBase64String(encryptedData);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts a Text string using a key and industry standard encryption modes - Rijndael will be default which is the same as AES 256 bit encryption.
|
||||
/// </summary>
|
||||
/// <param name="text">text string to decrypt</param>
|
||||
/// <param name="key">key to use to decrypt the string</param>
|
||||
/// <param name="encryptionMode">Mode of encryption of choice - "DES" or "RC2" or "Rijndael" or "TripleDES" - Default will be "Rijndael"</param>
|
||||
/// <returns>decrypted text</returns>
|
||||
public string DecryptText(string text, string key, string encryptionMode)
|
||||
{
|
||||
string decryptedData = string.Empty;
|
||||
decryptedData = Decrypt(Convert.FromBase64String(text), key, encryptionMode);
|
||||
return decryptedData;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts Key Text
|
||||
/// </summary>
|
||||
/// <param name="text">key text</param>
|
||||
/// <param name="key">key to use when encrypting the key</param>
|
||||
/// <returns></returns>
|
||||
public string EncryptText(string text, int key)
|
||||
{
|
||||
return Encrypt(text, key, PerSeTextEncryptionTypes.Text);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts text
|
||||
/// </summary>
|
||||
/// <param name="text">Text to encrypt</param>
|
||||
/// <returns>the text encrypted</returns>
|
||||
public string EncryptText(string text)
|
||||
{
|
||||
string strEncryptValue;
|
||||
|
||||
strEncryptValue = Encrypt(text, PerSeTextEncryptionTypes.Text);
|
||||
|
||||
return strEncryptValue;
|
||||
|
||||
//return Encrypt( text, PerSeTextEncryptionTypes.Text );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts text
|
||||
/// </summary>
|
||||
/// <param name="text">Text to encrypt</param>
|
||||
/// <returns>the text encrypted</returns>
|
||||
public string EncryptText(string text, bool EnsureUniqueKey, string assemblyname)
|
||||
{
|
||||
string strEncryptValue;
|
||||
|
||||
strEncryptValue = Encrypt(text, PerSeTextEncryptionTypes.Text);
|
||||
|
||||
if (EnsureUniqueKey && !String.IsNullOrEmpty(assemblyname))
|
||||
strEncryptValue = SimpleStringBinaryConverter.GetString(strEncryptValue, assemblyname);
|
||||
|
||||
return strEncryptValue;
|
||||
|
||||
//return Encrypt( text, PerSeTextEncryptionTypes.Text );
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts the text.
|
||||
/// </summary>
|
||||
/// <param name="text">The text.</param>
|
||||
/// <returns></returns>
|
||||
/// Change Made On: 7/15/2010
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
public ReadOnlyCollection<String> EncryptText(ReadOnlyCollection<String> text)
|
||||
{
|
||||
List<string> result = new List<string>();
|
||||
foreach (string value in text)
|
||||
{
|
||||
result.Add(Encrypt(value, PerSeTextEncryptionTypes.Text));
|
||||
}
|
||||
ReadOnlyCollection<string> temp = new ReadOnlyCollection<string>(result);
|
||||
return temp;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts a Text string using an Embedded key
|
||||
/// </summary>
|
||||
/// <param name="encryptedText">encrypted text to decrypt</param>
|
||||
/// <param name="encryptionType"></param>
|
||||
/// <returns>decrypted text string</returns>
|
||||
private string Decrypt(string encryptedText, PerSeTextEncryptionTypes encryptionType)
|
||||
{
|
||||
try
|
||||
{
|
||||
StringBuilder decryptedText = new StringBuilder();
|
||||
int key = GetEmbeddedKey(encryptedText);
|
||||
int index = 0;
|
||||
|
||||
if (key != -1)
|
||||
{
|
||||
index = encryptedText.Length - (KeyStringLength - SplitKeyIndex) + 1;
|
||||
if (index >= (SplitKeyIndex + 1))
|
||||
{
|
||||
string encryptedTextWithoutKey = encryptedText.Substring(SplitKeyIndex, (index - SplitKeyIndex - 1));
|
||||
decryptedText.Append(Decrypt(encryptedTextWithoutKey, key, encryptionType));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (index = 0; index < InvalidStringCharacters; index++)
|
||||
{
|
||||
int charIndex = RandomNumber(ValidTextCharacters.Length);
|
||||
decryptedText.Append(ValidTextCharacters[charIndex]);
|
||||
}
|
||||
}
|
||||
|
||||
return decryptedText.ToString();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error Decrypting string", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts a text string
|
||||
/// </summary>
|
||||
/// <param name="encryptedText">Encrypted Text to decrypt</param>
|
||||
/// <param name="key">key to use when decrypting the text</param>
|
||||
/// <param name="encryptionType">the type of text to decrypt</param>
|
||||
/// <returns>the encrypted string decrypted</returns>
|
||||
private string Decrypt(string encryptedText, int key, PerSeTextEncryptionTypes encryptionType)
|
||||
{
|
||||
try
|
||||
{
|
||||
string validCharacters;
|
||||
string encryptionCodeCharacters;
|
||||
int extraCharacerOdds;
|
||||
int extraCharacters;
|
||||
int realCharacters;
|
||||
int originalKey;
|
||||
|
||||
encryptionCodeCharacters = GenerateEncryptionCode(key, encryptionType);
|
||||
|
||||
originalKey = _currentRandomNumber;
|
||||
_currentRandomNumber = key;
|
||||
|
||||
switch (encryptionType)
|
||||
{
|
||||
case PerSeTextEncryptionTypes.Code:
|
||||
{
|
||||
validCharacters = ValidCodeCharacters;
|
||||
extraCharacters = 0;
|
||||
realCharacters = encryptedText.Length;
|
||||
extraCharacerOdds = 0;
|
||||
break;
|
||||
}
|
||||
case PerSeTextEncryptionTypes.Filename:
|
||||
{
|
||||
validCharacters = ValidFilenameCharacters;
|
||||
extraCharacters = 0;
|
||||
realCharacters = encryptedText.Length;
|
||||
extraCharacerOdds = 0;
|
||||
break;
|
||||
}
|
||||
default: // Text
|
||||
{
|
||||
validCharacters = ValidTextCharacters;
|
||||
extraCharacters = RandomNumber(MaxExtraEncryptionCharacters + 1);
|
||||
realCharacters = encryptedText.Length - extraCharacters;
|
||||
if (realCharacters > 0)
|
||||
extraCharacerOdds = (int)Decimal.Truncate((decimal)((50 * extraCharacters) / realCharacters));
|
||||
else
|
||||
extraCharacerOdds = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int index = 0;
|
||||
int characterPositionIndex;
|
||||
StringBuilder decryptedText = new StringBuilder();
|
||||
bool isFilename = (encryptionType == PerSeTextEncryptionTypes.Filename);
|
||||
|
||||
while (realCharacters > 0)
|
||||
{
|
||||
if (extraCharacters > 0)
|
||||
{
|
||||
if (extraCharacerOdds >= (RandomNumber(100) + 1))
|
||||
{
|
||||
RandomNumber(0); // Need (unused) call here to keep in synch with encrypt side
|
||||
index++;
|
||||
--extraCharacters;
|
||||
}
|
||||
}
|
||||
|
||||
characterPositionIndex = encryptionCodeCharacters.IndexOf(encryptedText[index]);
|
||||
if (characterPositionIndex < 0)
|
||||
{
|
||||
decryptedText.Append(encryptedText[index]);
|
||||
}
|
||||
else
|
||||
{
|
||||
characterPositionIndex = characterPositionIndex - RandomNumber(validCharacters.Length) - 1;
|
||||
while (characterPositionIndex < 0)
|
||||
{
|
||||
characterPositionIndex += validCharacters.Length;
|
||||
}
|
||||
decryptedText.Append(validCharacters[characterPositionIndex]);
|
||||
}
|
||||
|
||||
// Since all subdirectories of a directory path need to be encrypted/decrypted
|
||||
// identically, we reset the seed value whenever we start a new subdirectory.
|
||||
if (isFilename && (encryptedText[index] == '\\'))
|
||||
{
|
||||
_currentRandomNumber = key;
|
||||
}
|
||||
|
||||
index++;
|
||||
realCharacters--;
|
||||
}
|
||||
_currentRandomNumber = originalKey;
|
||||
|
||||
return decryptedText.ToString();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error decrypting string", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts an encrypted key
|
||||
/// </summary>
|
||||
/// <param name="encryptedKey">The encrypted key.</param>
|
||||
/// <returns>the key in it's original integer form</returns>
|
||||
private int DecryptKey(string encryptedKey)
|
||||
{
|
||||
try
|
||||
{
|
||||
int count;
|
||||
int index;
|
||||
int maxIndex;
|
||||
int tempKey;
|
||||
int decryptedKey;
|
||||
int value;
|
||||
|
||||
maxIndex = KeyEncryptionString.Length;
|
||||
tempKey = 0;
|
||||
|
||||
for (count = 1; count < encryptedKey.Length; count++)
|
||||
{
|
||||
index = KeyEncryptionString.IndexOf(encryptedKey[count]);
|
||||
value = index - KeyEncryptionString.IndexOf(encryptedKey[count - 1]);
|
||||
|
||||
if (value < 0)
|
||||
{
|
||||
value += maxIndex;
|
||||
}
|
||||
|
||||
if (value == 16)
|
||||
{
|
||||
value = 0;
|
||||
}
|
||||
|
||||
tempKey = (tempKey << EncryptionKeyShift) + (value & EncryptionKeyBitMask);
|
||||
}
|
||||
|
||||
decryptedKey = 0;
|
||||
for (count = 0; count < (16 / 4); count++)
|
||||
{
|
||||
decryptedKey = (decryptedKey << EncryptionKeyShift) | (tempKey & EncryptionKeyBitMask);
|
||||
tempKey = tempKey >> EncryptionKeyShift;
|
||||
}
|
||||
|
||||
return decryptedKey;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error decrypting key", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Retrieves the embedded key out of Encrypted Text
|
||||
/// </summary>
|
||||
/// <param name="encryptedText">the encrypted text to retrieve the embedded key from</param>
|
||||
/// <returns>embedded encrypted key</returns>
|
||||
private int GetEmbeddedKey(string encryptedText)
|
||||
{
|
||||
int index;
|
||||
int decryptedKey;
|
||||
string encryptedKey;
|
||||
|
||||
decryptedKey = -1;
|
||||
index = encryptedText.Length - (KeyStringLength - SplitKeyIndex) + 1;
|
||||
|
||||
if (index >= (SplitKeyIndex + 1))
|
||||
{
|
||||
encryptedKey = encryptedText.Substring(0, SplitKeyIndex) +
|
||||
encryptedText.Substring(index - 1);
|
||||
decryptedKey = DecryptKey(encryptedKey);
|
||||
}
|
||||
|
||||
return decryptedKey;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates a valid Encryption Key
|
||||
/// </summary>
|
||||
/// <returns>encryption key</returns>
|
||||
private int GenerateEncryptionKey()
|
||||
{
|
||||
string charString;
|
||||
string codeString;
|
||||
int key;
|
||||
int identicalCharacterCount;
|
||||
bool isKeyValid = false;
|
||||
|
||||
do
|
||||
{
|
||||
for (int i = 0; i < EncryptionKeySkipKeys; i++)
|
||||
{
|
||||
RandomNumber(EncryptionKeySeed);
|
||||
}
|
||||
key = _currentRandomNumber;
|
||||
|
||||
codeString = GenerateEncryptionCode(key);
|
||||
charString = ValidTextCharacters;
|
||||
|
||||
identicalCharacterCount = 0;
|
||||
for (int i = 0; i < codeString.Length; i++)
|
||||
{
|
||||
if (codeString[i] == charString[i])
|
||||
{
|
||||
identicalCharacterCount++;
|
||||
}
|
||||
}
|
||||
isKeyValid = ((identicalCharacterCount < EncryptionKeyMaxUnchangedCount) && (key != -1));
|
||||
}
|
||||
while (!isKeyValid);
|
||||
|
||||
return key;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts text for the specified encryption type
|
||||
/// </summary>
|
||||
/// <param name="decryptedText">text to encrypt</param>
|
||||
/// <param name="encryptionType">encryption type to perform</param>
|
||||
/// <returns>the text encrypted</returns>
|
||||
private string Encrypt(string decryptedText, PerSeTextEncryptionTypes encryptionType)
|
||||
{
|
||||
int decryptedKey;
|
||||
string encryptedKey = string.Empty;
|
||||
|
||||
decryptedKey = GenerateEncryptionKey();
|
||||
encryptedKey = EncryptKey(decryptedKey);
|
||||
|
||||
string encryptedText = Encrypt(decryptedText, decryptedKey, encryptionType);
|
||||
encryptedText = encryptedKey.Substring(0, SplitKeyIndex) + encryptedText + encryptedKey.Substring(SplitKeyIndex, encryptedKey.Length - SplitKeyIndex);
|
||||
|
||||
return encryptedText;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts text for the specified encryption type
|
||||
/// </summary>
|
||||
/// <param name="decryptedText">text to encrypt</param>
|
||||
/// <param name="key">key to use for encryption</param>
|
||||
/// <param name="encryptionType">type of encryption to perform</param>
|
||||
/// <returns>decrypted text encrypted </returns>
|
||||
private string Encrypt(string decryptedText, int key, PerSeTextEncryptionTypes encryptionType)
|
||||
{
|
||||
try
|
||||
{
|
||||
string charString = string.Empty;
|
||||
string codeString = string.Empty;
|
||||
int extraCharacterOdds;
|
||||
int extraCharacters;
|
||||
int posIndex;
|
||||
int originalKey;
|
||||
StringBuilder encryptedText = new StringBuilder();
|
||||
|
||||
codeString = GenerateEncryptionCode(key);
|
||||
originalKey = _currentRandomNumber;
|
||||
|
||||
_currentRandomNumber = key;
|
||||
|
||||
charString = ValidTextCharacters;
|
||||
extraCharacters = RandomNumber(MaxExtraEncryptionCharacters + 1);
|
||||
|
||||
if (decryptedText.Length > 0)
|
||||
{
|
||||
extraCharacterOdds = (50 * extraCharacters) / decryptedText.Length;
|
||||
}
|
||||
else
|
||||
{
|
||||
extraCharacterOdds = 0;
|
||||
}
|
||||
|
||||
if (decryptedText.Length > 0)
|
||||
{
|
||||
for (int i = 0; i < decryptedText.Length; i++)
|
||||
{
|
||||
if (extraCharacters > 0)
|
||||
{
|
||||
if (extraCharacterOdds >= (RandomNumber(100) + 1))
|
||||
{
|
||||
posIndex = RandomNumber(codeString.Length) + 1;
|
||||
if (posIndex >= codeString.Length)
|
||||
{
|
||||
posIndex = codeString.Length - 1;
|
||||
}
|
||||
encryptedText.Append(codeString[posIndex]);
|
||||
extraCharacters--;
|
||||
}
|
||||
}
|
||||
posIndex = charString.IndexOf(decryptedText[i]);
|
||||
if (posIndex < 0)
|
||||
{
|
||||
encryptedText.Append(decryptedText[i]);
|
||||
}
|
||||
else
|
||||
{
|
||||
posIndex = ((posIndex + RandomNumber(codeString.Length) + 1) % codeString.Length);
|
||||
encryptedText.Append(codeString[posIndex]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while (extraCharacters > 0)
|
||||
{
|
||||
posIndex = RandomNumber(codeString.Length) + 1;
|
||||
if (posIndex >= codeString.Length)
|
||||
{
|
||||
posIndex = codeString.Length - 1;
|
||||
}
|
||||
encryptedText.Append(codeString[posIndex]);
|
||||
extraCharacters--;
|
||||
}
|
||||
_currentRandomNumber = originalKey;
|
||||
|
||||
return encryptedText.ToString();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error Encrypting key", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts a Key
|
||||
/// </summary>
|
||||
/// <param name="decryptedKey">key to encrypt</param>
|
||||
/// <returns>encrypted key</returns>
|
||||
private string EncryptKey(int decryptedKey)
|
||||
{
|
||||
int count;
|
||||
int index;
|
||||
int maxIndex;
|
||||
StringBuilder encryptedKey = new StringBuilder();
|
||||
int value;
|
||||
|
||||
maxIndex = KeyEncryptionString.Length;
|
||||
index = RandomNumber(maxIndex);
|
||||
encryptedKey.Append(KeyEncryptionString[index]);
|
||||
|
||||
for (count = 0; count < (16 / 4); count++)
|
||||
{
|
||||
value = decryptedKey & EncryptionKeyBitMask;
|
||||
if (value == 0)
|
||||
{
|
||||
value = 16;
|
||||
}
|
||||
decryptedKey >>= EncryptionKeyShift;
|
||||
index = ((index + value) % maxIndex);
|
||||
encryptedKey.Append(KeyEncryptionString[index]);
|
||||
}
|
||||
return encryptedKey.ToString();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates a Random number based on the Value, seeds and other custom inhouse
|
||||
/// values
|
||||
/// </summary>
|
||||
/// <param name="seed">random number seed</param>
|
||||
/// <returns></returns>
|
||||
private int RandomNumber(int seed)
|
||||
{
|
||||
float newValue;
|
||||
int newRandomNumber;
|
||||
|
||||
_currentRandomNumber = ((_currentRandomNumber * RandomNumberMultiplier) + RandomNumberExtraValue) & RandomNumberBitMask;
|
||||
newValue = _currentRandomNumber / RandomNumberDivisor;
|
||||
newRandomNumber = (int)Decimal.Truncate((decimal)(seed * newValue));
|
||||
|
||||
return newRandomNumber;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates an Encryption Code String based on the Seed
|
||||
/// </summary>
|
||||
/// <param name="seed">seed to build the encryption code string for</param>
|
||||
/// <returns>encryption code string</returns>
|
||||
private string GenerateEncryptionCode(int seed)
|
||||
{
|
||||
return GenerateEncryptionCode(seed, PerSeTextEncryptionTypes.Text);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Generates an Encryption Code String based on the Seed and Encryption Type
|
||||
/// </summary>
|
||||
/// <param name="seed">seed to build the encryption code string for</param>
|
||||
/// <param name="encryptionType">Encryption type to build the encryption code string for</param>
|
||||
/// <returns>encryption code string</returns>
|
||||
private string GenerateEncryptionCode(int seed, PerSeTextEncryptionTypes encryptionType)
|
||||
{
|
||||
try
|
||||
{
|
||||
StringBuilder encryptionCodeString = new StringBuilder();
|
||||
StringBuilder validEncryptionCharacters = new StringBuilder();
|
||||
|
||||
switch (encryptionType)
|
||||
{
|
||||
case PerSeTextEncryptionTypes.Code:
|
||||
validEncryptionCharacters.Append(ValidCodeCharacters);
|
||||
break;
|
||||
|
||||
case PerSeTextEncryptionTypes.Filename:
|
||||
validEncryptionCharacters.Append(ValidFilenameCharacters);
|
||||
break;
|
||||
|
||||
default: // Text
|
||||
validEncryptionCharacters.Append(ValidTextCharacters);
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
int index;
|
||||
int originalKey = _currentRandomNumber;
|
||||
|
||||
_currentRandomNumber = seed;
|
||||
while (validEncryptionCharacters.Length > 0)
|
||||
{
|
||||
index = RandomNumber(validEncryptionCharacters.Length);
|
||||
encryptionCodeString.Append(validEncryptionCharacters[index]);
|
||||
validEncryptionCharacters.Remove(index, 1);
|
||||
}
|
||||
_currentRandomNumber = originalKey;
|
||||
|
||||
return encryptionCodeString.ToString();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("Error Generating Encryption code", ex);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Encrypts the specified text.
|
||||
/// </summary>
|
||||
/// <param name="text">The text.</param>
|
||||
/// <param name="key">The key.</param>
|
||||
/// <param name="encryptionMode">The encryption mode.</param>
|
||||
/// <returns></returns>
|
||||
/// Change Made On: 5/6/2009
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
private byte[] Encrypt(string text, string key, string encryptionMode)
|
||||
{
|
||||
SymmetricAlgorithm cryptoObj = null;
|
||||
cryptoObj = GetEncryptionProviderObject(encryptionMode);
|
||||
|
||||
byte[] bytIn = Encoding.ASCII.GetBytes(text);
|
||||
// create a MemoryStream so that the process can be done without I/O files
|
||||
MemoryStream ms = new MemoryStream();
|
||||
|
||||
// set the private key
|
||||
cryptoObj.Key = GetLegalKey(key, encryptionMode);
|
||||
cryptoObj.IV = GetLegalVectorSize(key, encryptionMode);
|
||||
|
||||
// create an Encryptor from the Provider Service instance
|
||||
ICryptoTransform encrypto = cryptoObj.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();
|
||||
cs.Close();
|
||||
|
||||
return ms.ToArray();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Decrypts the specified ciphertext.
|
||||
/// </summary>
|
||||
/// <param name="ciphertext">The ciphertext.</param>
|
||||
/// <param name="key">The key.</param>
|
||||
/// <param name="encryptionMode">The encryption mode.</param>
|
||||
/// <returns></returns>
|
||||
/// Change Made On: 5/6/2009
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
private string Decrypt(byte[] ciphertext, string key, string encryptionMode)
|
||||
{
|
||||
SymmetricAlgorithm deCryptoObj = null;
|
||||
deCryptoObj = GetEncryptionProviderObject(encryptionMode);
|
||||
|
||||
// create a MemoryStream with the input
|
||||
MemoryStream ms = new MemoryStream(ciphertext, 0, ciphertext.Length);
|
||||
|
||||
// set the private key
|
||||
deCryptoObj.Key = GetLegalKey(key, encryptionMode);
|
||||
deCryptoObj.IV = GetLegalVectorSize(key, encryptionMode);
|
||||
|
||||
// create a Decryptor from the Provider Service instance
|
||||
ICryptoTransform encrypto = deCryptoObj.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
|
||||
StreamReader sr = new StreamReader(cs);
|
||||
return sr.ReadToEnd();
|
||||
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the encryption provider object.
|
||||
/// </summary>
|
||||
/// <param name="encryptionMode">The encryption mode.</param>
|
||||
/// <returns></returns>
|
||||
/// Change Made On: 5/6/2009
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
private SymmetricAlgorithm GetEncryptionProviderObject(string encryptionMode)
|
||||
{
|
||||
SymmetricAlgorithm tmpCryptoObj = null;
|
||||
|
||||
switch (encryptionMode)
|
||||
{
|
||||
case "DES":
|
||||
tmpCryptoObj = new DESCryptoServiceProvider();
|
||||
break;
|
||||
case "RC2":
|
||||
tmpCryptoObj = new RC2CryptoServiceProvider();
|
||||
break;
|
||||
case "Rijndael":
|
||||
tmpCryptoObj = new RijndaelManaged();
|
||||
break;
|
||||
case "TripleDES":
|
||||
tmpCryptoObj = new TripleDESCryptoServiceProvider();
|
||||
break;
|
||||
default:
|
||||
tmpCryptoObj = new RijndaelManaged();
|
||||
break;
|
||||
}
|
||||
|
||||
return tmpCryptoObj;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the legal key.
|
||||
/// </summary>
|
||||
/// <param name="Key">The key.</param>
|
||||
/// <param name="encryptionMode">The encryption mode.</param>
|
||||
/// <returns></returns>
|
||||
/// Change Made On: 5/6/2009
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
private byte[] GetLegalKey(string Key, string encryptionMode)
|
||||
{
|
||||
string sTemp = Key;
|
||||
|
||||
switch (encryptionMode)
|
||||
{
|
||||
case "DES":
|
||||
case "RC2":
|
||||
if (Key.Length > 8)
|
||||
{
|
||||
sTemp = Key.Substring(0, 8);
|
||||
}
|
||||
break;
|
||||
case "TripleDES":
|
||||
if (Key.Length > 16)
|
||||
{
|
||||
sTemp = Key.Substring(0, 16);
|
||||
}
|
||||
break;
|
||||
case "Rijndael":
|
||||
default:
|
||||
if (Key.Length > 32)
|
||||
{
|
||||
sTemp = Key.Substring(0, 32);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// convert the secret key to byte array
|
||||
return ASCIIEncoding.ASCII.GetBytes(sTemp);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size of the legal vector.
|
||||
/// </summary>
|
||||
/// <param name="Key">The key.</param>
|
||||
/// <param name="encryptionMode">The encryption mode.</param>
|
||||
/// <returns></returns>
|
||||
/// Change Made On: 5/6/2009
|
||||
/// Change Made By: Shane.Calhoun
|
||||
/// ==============================================
|
||||
private byte[] GetLegalVectorSize(string Key, string encryptionMode)
|
||||
{
|
||||
string sTemp = Key;
|
||||
|
||||
switch (encryptionMode)
|
||||
{
|
||||
case "DES":
|
||||
case "RC2":
|
||||
if (Key.Length > 8)
|
||||
{
|
||||
sTemp = Key.Substring(0, 8);
|
||||
}
|
||||
break;
|
||||
case "TripleDES":
|
||||
if (Key.Length > 8)
|
||||
{
|
||||
sTemp = Key.Substring(0, 8);
|
||||
}
|
||||
break;
|
||||
case "Rijndael":
|
||||
default:
|
||||
if (Key.Length > 16)
|
||||
{
|
||||
sTemp = Key.Substring(0, 16);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
// convert the secret key to byte array
|
||||
return ASCIIEncoding.ASCII.GetBytes(sTemp);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user