/// <summary>
/// 生成3重des密匙
/// </summary>
/// <returns></returns>
public static byte[] GenTripleDesKey()
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.GenerateKey();
return(des.Key);
}
public static string GenerateKey()
{
TripleDESCryptoServiceProvider TDES = new TripleDESCryptoServiceProvider();
TDES.GenerateKey();
return(System.Text.Encoding.ASCII.GetString(TDES.Key));
}
private void buttonOK_Click(object sender, EventArgs e)
{
string str = textBoxInput.Text;
if (str.Length == 0)
{
MessageBox.Show("请输入被加密的字符串");
return;
}
//加密
try
{
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//随机生成密钥Key 和初始化向量IV
tdes.GenerateKey();
tdes.GenerateIV();
textBoxKey.Text = Encoding.UTF8.GetString(tdes.Key);
//得到加密后的字节流
byte[] encryptedBytes = EncryptText(str, tdes.Key, tdes.IV);
//显示加密后的字符串
textBoxEncrypt.Text = Encoding.UTF8.GetString(encryptedBytes);
//解密
string decryptString = DecryptText(encryptedBytes, tdes.Key, tdes.IV);
//显示解密后的字符串
textBoxDecrypt.Text = decryptString;
}
catch (Exception err)
{
MessageBox.Show(err.Message, "出错");
}
}
public static String DecryptString(String in_string)
{
String return_value;
using (TripleDESCryptoServiceProvider tdsAlg = new TripleDESCryptoServiceProvider())
{
tdsAlg.GenerateKey();
tdsAlg.GenerateIV();
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = tdsAlg.CreateDecryptor(tdsAlg.Key, tdsAlg.IV);
// Create the streams used for decryption.
using (MemoryStream msDecrypt = new MemoryStream(System.Text.Encoding.ASCII.GetBytes(in_string)))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
return_value = srDecrypt.ReadToEnd();
}
}
}
}
return(return_value);
}
/// <summary>
/// Event that fires when tripledes encrypt is clicked
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnTripleDESEncrypt_Click(object sender, RoutedEventArgs e)
{
ASCIIEncoding encoding = new ASCIIEncoding();
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.KeySize = ((ListItem)this.cboTripleDESKeySize.SelectedItem).Value;
tripleDES.Mode = (CipherMode)((ListItem)this.cboTripleDESMode.SelectedItem).Value;
tripleDES.Padding = (PaddingMode)((ListItem)this.cboTripleDESPadding.SelectedItem).Value;
//des.BlockSize = ;
tripleDES.GenerateIV();
this.txtTripleDESIV.Text = Convert.ToBase64String(tripleDES.IV);
//generate the key and insert it into the text box
tripleDES.GenerateKey();
this.txtTripleDESPassword.Text = Convert.ToBase64String(tripleDES.Key);
byte[] byteInputText = encoding.GetBytes(this.txtTripleDESInput.Text);
byte[] cipherText;
using (ICryptoTransform crypto = tripleDES.CreateEncryptor())
{
cipherText = crypto.TransformFinalBlock(byteInputText, 0, byteInputText.Length - 1);
tripleDES.Clear();
}
this.txtTripleDESOutput.Text = Convert.ToBase64String(cipherText);
}
} //compute hash from arguments and return hash value as string
private static string GetTripleDESHash(string text)
{
//create variables for computing hash and making it a string
UnicodeEncoding UniCode = new UnicodeEncoding();
byte[] HashResult;
byte[] msg = UniCode.GetBytes(text);
TripleDES hashString = new TripleDESCryptoServiceProvider();
//generate a weak KEY and Initialization Vector for the hash algorithm
hashString.GenerateKey();
hashString.GenerateIV();
ICryptoTransform encryptor = hashString.CreateEncryptor(hashString.Key, hashString.IV);
string Str = "";
//compute hash with TripleDES module and format output as string
//convert bytes in HashResult to string values
HashResult = encryptor.TransformFinalBlock(msg, 0, msg.Length);
foreach (byte x in HashResult)
{
Str += String.Format("{0:x2}", x);
}
//clear excess resource usage
hashString.Clear();
return(Str);
} //compute hash from arguments and return hash value as string
public static String EncryptString(String in_string)
{
String return_value;
using (TripleDESCryptoServiceProvider tdsAlg = new TripleDESCryptoServiceProvider())
{
tdsAlg.GenerateKey();
tdsAlg.GenerateIV();
// Create a decrytor to perform the stream transform.
ICryptoTransform encryptor = tdsAlg.CreateEncryptor(tdsAlg.Key, tdsAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(in_string);
}
return_value = msEncrypt.ToString();
}
}
}
return(return_value);
}
public static string GenerateKey()
{
var crypto = new TripleDESCryptoServiceProvider();
crypto.GenerateKey();
return(Convert.ToBase64String(crypto.Key));
}
private void btnDesencriptar_Click(object sender, RoutedEventArgs e)
{
TripleDESCryptoServiceProvider Algoritmo = new TripleDESCryptoServiceProvider();
//Generación de clave aleatoria
Algoritmo.GenerateKey();
Algoritmo.GenerateIV();
Algoritmo.Key = bkey;
Algoritmo.IV = bIV;
ICryptoTransform Transformacion = Algoritmo.CreateDecryptor();
//Generando el nuevo nombre del archivo desencriptado
string path = @txtFileDesEncriptar.Text;
string file = System.IO.Path.GetFileNameWithoutExtension(path);
string NewPath = path.Replace(file, file + "-desencriptado");
using (FileStream FsOrigen = new FileStream(txtFileDesEncriptar.Text, FileMode.Open, FileAccess.Read))
{
using (CryptoStream Cs = new CryptoStream(FsOrigen, Transformacion, CryptoStreamMode.Read))
{
using (StreamReader Sr = new StreamReader(Cs))
{
string Cadena = Sr.ReadToEnd();
File.WriteAllText(NewPath, Cadena);
MessageBox.Show("Archivo desencriptado con éxito.", "Mensaje", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
FsOrigen.Close();
}
}
private void btnEncriptar_Click(object sender, RoutedEventArgs e)
{
TripleDESCryptoServiceProvider Algoritmo = new TripleDESCryptoServiceProvider();
//Generación de clave aleatoria
Algoritmo.GenerateKey();
Algoritmo.GenerateIV();
//Asignamos valores a los vectores
bkey = Algoritmo.Key;
bIV = Algoritmo.IV;
ICryptoTransform Transformacion = Algoritmo.CreateEncryptor();
//Ruta a encriptar
string path = @txtFileEncriptar.Text;
//Generando nueva ruta del archivo destino
string file = System.IO.Path.GetFileNameWithoutExtension(path);
string NewPath = path.Replace(file, file + "-encriptado");
using (FileStream FsDestino = new FileStream(NewPath, FileMode.OpenOrCreate, FileAccess.Write))
{
using (CryptoStream Cs = new CryptoStream(FsDestino, Transformacion, CryptoStreamMode.Write))
{
string Contenido = File.ReadAllText(@txtFileEncriptar.Text);
using (StreamWriter Sw = new StreamWriter(Cs))
{
Sw.Write(Contenido);
Sw.Close();
MessageBox.Show("Archivo encriptado con éxito.", "Mensaje", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
FsDestino.Close();
}
}
private SecurityKeyGenerator()
{
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.GenerateKey();
key = new SymmetricSecurityKey(Encoding.Unicode.GetBytes(tripleDES.Key.ToString()));
}
public static string GenerateTripleDESHexStringKey()
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.GenerateKey();
return(BytesArrayToHexString(des.Key));
}
static CryptoTools()
{
var config = GetConfig();
string existKey = config["EncryptionKey"];
if (string.IsNullOrEmpty(existKey) || existKey == "typeKeyHere")
{
TripleDESCryptoServiceProvider TDES = new TripleDESCryptoServiceProvider();
TDES.GenerateIV();
TDES.GenerateKey();
key = Convert.ToBase64String(TDES.Key);
string[] pathSplit = AppContext.BaseDirectory.Split("\\");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < pathSplit.Length - 1; i++)
{
sb.Append(pathSplit[i] + "\\");
if (pathSplit[i] == "MSDF.DataChecker.WebApp")
{
break;
}
}
sb.Append("appsettings.json");
string appsettingsPath = sb.ToString();
string fileContent = File.ReadAllText(appsettingsPath);
fileContent = fileContent.Replace("typeKeyHere", key);
File.WriteAllText(appsettingsPath, fileContent);
}
else
{
key = existKey;
}
}
public static void TestShims()
{
using (var alg = new TripleDESCryptoServiceProvider())
{
alg.BlockSize = 64;
Assert.Equal(64, alg.BlockSize);
var emptyIV = new byte[8];
alg.IV = emptyIV;
Assert.Equal(emptyIV, alg.IV);
alg.GenerateIV();
Assert.NotEqual(emptyIV, alg.IV);
alg.KeySize = 64 * 3;
Assert.Equal(64 * 3, alg.KeySize);
var knownKey = new byte[]
{
/* k1 */ 0, 1, 2, 3, 4, 5, 6, 7,
/* k2 */ 0, 0, 0, 2, 4, 6, 0, 1,
/* k3 */ 0, 1, 2, 3, 4, 5, 6, 7,
};
alg.Key = knownKey;
Assert.Equal(knownKey, alg.Key);
alg.GenerateKey();
Assert.NotEqual(knownKey, alg.Key);
alg.Mode = CipherMode.ECB;
Assert.Equal(CipherMode.ECB, alg.Mode);
alg.Padding = PaddingMode.PKCS7;
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
}
public static string GetSecretKey()
{
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.GenerateKey();
return(Encoding.ASCII.GetString(tdes.Key));
}
public static string Generate()
{
var tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
tripleDESCryptoServiceProvider.GenerateKey();
return(System.Convert.ToBase64String(tripleDESCryptoServiceProvider.Key));
}
public string GenerateKeyInBase64()
{
TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider();
provider.GenerateKey();
return(Convert.ToBase64String(provider.Key));
}
internal static string GENERATEUR_DE_CLES()
{
trip = new TripleDESCryptoServiceProvider();
trip.GenerateKey();
return(Convert.ToBase64String(trip.Key));
}
/**
* @brief
* Generates a secret key used for symmetric encryption and decryption
*/
public static byte[] generateKey()
{
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.GenerateKey();
return(tripleDES.Key);
}
public static void TestShims()
{
using (var alg = new TripleDESCryptoServiceProvider())
{
alg.BlockSize = 64;
Assert.Equal(64, alg.BlockSize);
var emptyIV = new byte[8];
alg.IV = emptyIV;
Assert.Equal(emptyIV, alg.IV);
alg.GenerateIV();
Assert.NotEqual(emptyIV, alg.IV);
alg.KeySize = 64 * 3;
Assert.Equal(64 * 3, alg.KeySize);
var knownKey = new byte[]
{
/* k1 */ 0, 1, 2, 3, 4, 5, 6, 7,
/* k2 */ 0, 0, 0, 2, 4, 6, 0, 1,
/* k3 */ 0, 1, 2, 3, 4, 5, 6, 7,
};
alg.Key = knownKey;
Assert.Equal(knownKey, alg.Key);
alg.GenerateKey();
Assert.NotEqual(knownKey, alg.Key);
alg.Mode = CipherMode.ECB;
Assert.Equal(CipherMode.ECB, alg.Mode);
alg.Padding = PaddingMode.PKCS7;
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
}
private void Listener()
{
var tcpClient = new TcpClient(Host, Config.Port);
Socket = tcpClient.Client;
var secureMessage = Socket.Receive <SecureMessage>();
var rsa = Config.CreateRsa();
rsa.ImportParameters(secureMessage.ToRsaParameters());
symmetric = new TripleDESCryptoServiceProvider();
symmetric.GenerateIV();
symmetric.GenerateKey();
Socket.SendRSA(new SecureReplyMessage(Nick, symmetric.Key, symmetric.IV), rsa);
var res = true;
while (res)
{
try
{
lastStateMessage = Socket.ReceiveTripleDES <GameStateMessage>(symmetric);
if (GameStateChanged != null)
{
GameStateChanged(lastStateMessage);
}
}
catch (SocketException se)
{
res = false;
}
}
}
private static SymmetricAlgorithm CreateAlgorithm()
{
//Modify it if we need any different Algorithm;
//Probbale options are:
// 1. RijndaelManaged
// 2. DESCryptoServiceProvider
// 3. RC2CryptoServiceProvider
// 4. TripleDESCryptoServiceProvider
SymmetricAlgorithm crypto = new TripleDESCryptoServiceProvider();
if ((_iv == null) || (_key == null))
{
lock (typeof(StringEncrypter))
{
//By Using Generate the Same QueryString will
//be Differentl by time to time, But we need to make sure
//that the Key and the IV remains same between
//the application starts and end.
crypto.GenerateIV();
crypto.GenerateKey();
_iv = crypto.IV;
_key = crypto.Key;
}
}
crypto.IV = _iv;
crypto.Key = _key;
return(crypto);
}
public static byte[] GenerateSymmetricalKey()
{
TripleDES cryptor = new TripleDESCryptoServiceProvider();
cryptor.GenerateKey();
return(cryptor.Key);
}
/// <summary>
/// 获取加密和解密时用的key和iv
/// </summary>
/// <param name="providerType">算法类型</param>
/// <param name="key"></param>
/// <param name="iv"></param>
public static void GenerateCryptKeyAndIV(CryptProviderType providerType, out byte[] key, out byte[] iv)
{
key = null;
iv = null;
switch (providerType)
{
case CryptProviderType.AES:
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.GenerateKey();
aes.GenerateIV();
key = aes.Key;
iv = aes.IV;
return;
case CryptProviderType.DES:
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.GenerateKey();
des.GenerateIV();
key = des.Key;
iv = des.IV;
return;
case CryptProviderType.TripleDES:
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.GenerateKey();
tdes.GenerateIV();
key = tdes.Key;
iv = tdes.IV;
return;
default:
return;
}
}
/// <summary>
/// Generate new encryption key
/// </summary>
/// <param name="algId"></param>
/// <returns></returns>
public string GenerateKey(EncryptionAlgorithm algId)
{
byte[] NewKey = null;
// Pick the provider.
switch (algId)
{
case EncryptionAlgorithm.Des:
{
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
des.GenerateKey();
NewKey = des.Key;
des = null;
break;
}
case EncryptionAlgorithm.TripleDes:
{
TripleDES des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
des3.GenerateKey();
NewKey = des3.Key;
des3 = null;
break;
}
case EncryptionAlgorithm.Rc2:
{
RC2 rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
rc2.GenerateKey();
NewKey = rc2.Key;
rc2 = null;
break;
}
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
rijndael.Padding = PaddingMode.PKCS7;
rijndael.KeySize = 256;
rijndael.BlockSize = 256;
rijndael.GenerateKey();
NewKey = rijndael.Key;
rijndael = null;
break;
}
default:
{
throw new CryptographicException("Algorithm ID '" + algId +
"' not supported.");
}
}
return(Encoding.ASCII.GetString(NewKey));
}
public static Secret HybridEncrypt
(
RSACryptoServiceProvider encryptorPrivateKeyPfxProvider
, X509Certificate2 encryptorPublicKeyCer
, RSACryptoServiceProvider decryptorPublicKeyCerProvider
, HashSignatureMode signHashMode
, bool DoOAEPadding
, byte[] data
)
{
Secret secret = new Secret();
using (TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider())
{
provider.GenerateIV();
secret.EncryptorSharedEncryptedOnceIV = provider.IV;
provider.GenerateKey();
secret.EncryptorSharedEncryptedOnceKey = provider.Key;
secret.EncryptedData = provider.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
}
secret.EncryptorSharedEncryptedOnceIV = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceIV, DoOAEPadding);
secret.EncryptorSharedEncryptedOnceKey = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceKey, DoOAEPadding);
HashAlgorithm hashAlgorithm;
if (signHashMode == HashSignatureMode.SHA1)
{
hashAlgorithm = new SHA1CryptoServiceProvider();
}
else //(hashSignatureMode == HashSignatureMode.MD5)
{
hashAlgorithm = new MD5CryptoServiceProvider();
}
MemoryStream stream = new MemoryStream();
byte[] buffer = secret.EncryptorSharedEncryptedOnceIV;
stream.Write(buffer, 0, buffer.Length);
buffer = secret.EncryptorSharedEncryptedOnceKey;
stream.Write(buffer, 0, buffer.Length);
buffer = secret.EncryptedData;
stream.Position = 0;
buffer = hashAlgorithm.ComputeHash(stream);
stream.Close();
stream.Dispose();
secret.EncryptorHashSignature
= encryptorPrivateKeyPfxProvider
.SignHash
(
buffer
, Enum.GetName
(
signHashMode.GetType()
, signHashMode
)
);
secret.EncryptorPublicKeyCerRawData = encryptorPublicKeyCer.RawData;
secret.SignHashMode = signHashMode;
secret.DoOAEPadding = DoOAEPadding;
return(secret);
}
/// <summary>
/// TripleDES算法构造函数（KEY和IV随机生成）
/// </summary>
public TripleDES()
{
des = new TripleDESCryptoServiceProvider();
des.GenerateKey();
des.GenerateIV();
Key = Convert.ToBase64String(des.Key);
IV = Convert.ToBase64String(des.IV);
}
public TripleDesHelper()
{
TripleDES = new TripleDESCryptoServiceProvider();
TripleDES.GenerateIV();
TripleDES.GenerateKey();
DesKey = Convert.ToBase64String(TripleDES.Key);
DesVector = Convert.ToBase64String(TripleDES.IV);
}
// Generate a new symmetric key
public static string generateKey()
{
using (TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider())
{
tdes.GenerateKey();
return(ASCIIEncoding.ASCII.GetString(tdes.Key));
}
}
/// <summary>
/// The create key.
/// </summary>
/// <returns>
/// The create key.
/// </returns>
public static string CreateKey()
{
using (var provider = new TripleDESCryptoServiceProvider())
{
provider.GenerateKey();
return(BytesToHexString(provider.Key));
}
}
bool IKeyManagementDriver.GenerateKey(int session, int alg, int keySize, out int hKey)
{
hKey = -1;
try
{
SessionData ctx = ((SessionDriver)this.Hal.Session).GetSessionCtx(session);
switch ((AlgorithmType)alg)
{
case AlgorithmType.DES3_KEY_GEN:
{
TripleDESCryptoServiceProvider des3 = new TripleDESCryptoServiceProvider();
des3.KeySize = keySize;
des3.GenerateKey();
hKey = ctx.ObjectCtx.AddObject(CryptokiObjectType.Key, new KeyData(des3.Key, des3));
}
break;
case AlgorithmType.AES_KEY_GEN:
{
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.KeySize = keySize;
aes.GenerateKey();
hKey = ctx.ObjectCtx.AddObject(CryptokiObjectType.Key, new KeyData(aes.Key, aes));
}
break;
case AlgorithmType.GENERIC_SECRET_KEY_GEN:
{
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
byte[] keyBytes = new byte[keySize];
rng.GetBytes(keyBytes);
SecretKey key = new SecretKey(keySize, keyBytes);
hKey = ctx.ObjectCtx.AddObject(CryptokiObjectType.Key, new KeyData(keyBytes, key));
}
break;
default:
return(false);
}
}
catch
{
return(false);
}
return(true);
}
public static string Encrypt(string strData)
{
#region // Replace Words
string datas = strData;
// string[] dataArray = datas.Split(' ');
if (datas.Contains("ا") || datas.Contains("أ") || datas.Contains("إ"))
{
datas = datas.Replace("ا", "a11d");
datas = datas.Replace("أ", "a11s");
datas = datas.Replace("إ", "a11m");
}
if (datas.Contains("ب"))
{
datas= datas.Replace("ب", "l22k");
}
if (datas.Contains("ت"))
{
datas = datas.Replace("ت", "o33i");
}
if (datas.Contains("ث"))
{
datas = datas.Replace("ث", "t44r");
}
if (datas.Contains("ج"))
{
datas = datas.Replace("ج", "r55e");
}
if (datas.Contains("ح"))
{
datas = datas.Replace("ح", "u66y");
}
if (datas.Contains("خ"))
{
datas = datas.Replace("خ", "r77e");
}
if (datas.Contains("د"))
{
datas = datas.Replace("د", "d88s");
}
if (datas.Contains("ذ"))
{
datas = datas.Replace("ذ", "t99t");
}
if (datas.Contains("ر"))
{
datas = datas.Replace("ر", "e101w");
}
if (datas.Contains("ز"))
{
datas = datas.Replace("ز", "p111o");
}
if (datas.Contains("س"))
{
datas = datas.Replace("س", "y121t");
}
if (datas.Contains("ش"))
{
datas = datas.Replace("ش", "v131c");
}
if (datas.Contains("ص"))
{
datas = datas.Replace("ص", "t141r");
}
if (datas.Contains("ض"))
{
datas = datas.Replace("ض", "l151k");
}
if (datas.Contains("ط"))
{
datas = datas.Replace("ط", "t161r");
}
if (datas.Contains("ظ"))
{
datas.Replace("ظ", "e171w");
}
if (datas.Contains("ع"))
{
datas.Replace("ع", "f181d");
}
if (datas.Contains("غ"))
{
datas = datas.Replace("غ", "b191v");
}
if (datas.Contains("ف"))
{
datas = datas.Replace("ف", "n202b");
}
if (datas.Contains("ق"))
{
datas = datas.Replace("ق", "m212n");
}
if (datas.Contains("ك"))
{
datas = datas.Replace("ك", "h222g");
}
if (datas.Contains("ل"))
{
datas = datas.Replace("ل", "f232d");
}
if (datas.Contains("م"))
{
datas = datas.Replace("م", "r242e");
}
if (datas.Contains("ن"))
{
datas = datas.Replace("ن", "y252t");
}
if (datas.Contains("ه"))
{
datas = datas.Replace("ه", "w262q");
}
if (datas.Contains("و"))
{
datas = datas.Replace("و", "p272o");
}
if (datas.Contains("ي") || datas.Contains("ى"))
{
datas = datas.Replace("ي", "p282o");
datas = datas.Replace("ى", "p282u");
}
#endregion
byte[] data = ASCIIEncoding.ASCII.GetBytes(datas);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
if (Key == null)
{
tdes.GenerateKey();
tdes.GenerateIV();
Key = tdes.Key;
IV = tdes.IV;
}
else
{
tdes.Key = Key;
tdes.IV = IV;
}
ICryptoTransform encryptor = tdes.CreateEncryptor();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
cs.Write(data, 0, data.Length);
cs.FlushFinalBlock();
ms.Position = 0;
byte[] result = new byte[ms.Length];
ms.Read(result, 0, int.Parse(ms.Length.ToString()));
cs.Close();
string y = "";
for (int i = 0; i <= result.Length - 1; i++)
{
string x = result.GetValue(i).ToString();
if (x.Length == 0) {
x = "000" + x;
}
else if (x.Length == 1)
{
x = "00" + x;
}
else if (x.Length == 2)
{
x = "0" + x;
}
y = y + x;
}
return y;
}
public static string Encrypt(string strData)
{
#region // Replace Words
string datas = strData;
// string[] dataArray = datas.Split(' ');
datas = datas.ToUpper();
if (datas.Contains("A"))
{
datas = datas.Replace("A", "a11d");
}
if (datas.Contains("B"))
{
datas = datas.Replace("B", "l22k");
}
if (datas.Contains("C"))
{
datas = datas.Replace("C", "o33i");
}
if (datas.Contains("D"))
{
datas = datas.Replace("D", "t44r");
}
if (datas.Contains("E"))
{
datas = datas.Replace("E", "r55e");
}
if (datas.Contains("F"))
{
datas = datas.Replace("F", "u66y");
}
if (datas.Contains("G"))
{
datas = datas.Replace("G", "r77e");
}
if (datas.Contains("H"))
{
datas = datas.Replace("H", "d88s");
}
if (datas.Contains("I"))
{
datas = datas.Replace("I", "t99t");
}
if (datas.Contains("J"))
{
datas = datas.Replace("J", "e101w");
}
if (datas.Contains("K"))
{
datas = datas.Replace("K", "p111o");
}
if (datas.Contains("L"))
{
datas = datas.Replace("L", "y121t");
}
if (datas.Contains("M"))
{
datas = datas.Replace("M", "v131c");
}
if (datas.Contains("N"))
{
datas = datas.Replace("N", "t141r");
}
if (datas.Contains("O"))
{
datas = datas.Replace("O", "l151k");
}
if (datas.Contains("P"))
{
datas = datas.Replace("P", "t161r");
}
if (datas.Contains("Q"))
{
datas.Replace("Q", "e171w");
}
if (datas.Contains("R"))
{
datas.Replace("R", "f181d");
}
if (datas.Contains("S"))
{
datas = datas.Replace("S", "b191v");
}
if (datas.Contains("T"))
{
datas = datas.Replace("T", "n202b");
}
if (datas.Contains("U"))
{
datas = datas.Replace("U", "m212n");
}
if (datas.Contains("V"))
{
datas = datas.Replace("V", "h222g");
}
if (datas.Contains("W"))
{
datas = datas.Replace("W", "f232d");
}
if (datas.Contains("X"))
{
datas = datas.Replace("X", "r242e");
}
if (datas.Contains("Y"))
{
datas = datas.Replace("Y", "y252t");
}
if (datas.Contains("Z"))
{
datas = datas.Replace("Z", "w262q");
}
#endregion
byte[] data = ASCIIEncoding.ASCII.GetBytes(datas);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
if (Key == null)
{
tdes.GenerateKey();
tdes.GenerateIV();
Key = tdes.Key;
IV = tdes.IV;
}
else
{
tdes.Key = Key;
tdes.IV = IV;
}
ICryptoTransform encryptor = tdes.CreateEncryptor();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
cs.Write(data, 0, data.Length);
cs.FlushFinalBlock();
ms.Position = 0;
byte[] result = new byte[ms.Length];
ms.Read(result, 0, int.Parse(ms.Length.ToString()));
cs.Close();
string y = "";
for (int i = 0; i <= result.Length - 1; i++)
{
string x = result.GetValue(i).ToString();
if (x.Length == 0)
{
x = "000" + x;
}
else if (x.Length == 1)
{
x = "00" + x;
}
else if (x.Length == 2)
{
x = "0" + x;
}
y = y + x;
}
y = y.Substring(0,20);
return y;
}
