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();
}
}
public static string GenerateIV()
{
var crypto = new TripleDESCryptoServiceProvider();
crypto.GenerateIV();
return(Convert.ToBase64String(crypto.IV));
}
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;
}
}
}
/// <summary>
/// Desifrovani dat (3DES alg.)
/// - v pripade, ze vstupni data nemaji validni format vyhazuje GopayException
/// </summary>
///
/// <param name="data">data</param>
/// <param name="secureKey">secureKey</param>
///
/// <returns>desifrovany retezec</returns>
public static string Decrypt(string data, string secureKey)
{
byte[] cData = Hex2Byte(data);
// Vytvorime instanci 3DES algoritmu, nastavime parametry
TripleDESCryptoServiceProvider alg = new TripleDESCryptoServiceProvider();
alg.Mode = CipherMode.ECB;
alg.GenerateIV();
alg.Key = Encoding.Default.GetBytes(secureKey);
alg.Padding = PaddingMode.None;
// Vytvorime decryptor
ICryptoTransform decryptor = alg.CreateDecryptor(alg.Key, alg.IV);
MemoryStream ms;
CryptoStream cs;
String decryptedData = "";
try {
ms = new MemoryStream(cData.Length);
cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write);
cs.Write(cData, 0, cData.Length);
decryptedData = Encoding.UTF8.GetString(ms.ToArray());
} catch (Exception ex) {
throw new GopayException(ex.ToString());
}
return(decryptedData.TrimEnd('\0'));
}
public static string GenerateTripleDESHexStringIV()
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.GenerateIV();
return(BytesArrayToHexString(des.IV));
}
public string Encrypt(string input, string key)
{
while (input.Length % 8 != 0) //kriptuje samo do velicine deljuve sa 8 ostatak odbaci, zbog toga ova petlja
{
input = input + " ";
}
byte[] rawInput = Encoding.UTF8.GetBytes(input); //pravimo niz bajtova od unetog stringa
byte[] encrypted; //pomocni niz u koga enkriptujemo
//pravimo kljuc za 3DES
byte[] KeyFor3DES = ASCIIEncoding.ASCII.GetBytes(key);
TripleDESCryptoServiceProvider tripleDesCrypto = new TripleDESCryptoServiceProvider
{
Key = KeyFor3DES,
Mode = CipherMode.CBC,
Padding = PaddingMode.None
};
//Mora sa ovim algoritmom, sa starim radi samo u ECB modu
tripleDesCrypto.GenerateIV();
ICryptoTransform tripleDesEncrypt = tripleDesCrypto.CreateEncryptor();
using (MemoryStream mStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(mStream, tripleDesEncrypt, CryptoStreamMode.Write))
{
cryptoStream.Write(rawInput, 0, rawInput.Length);
encrypted = tripleDesCrypto.IV.Concat(mStream.ToArray()).ToArray();
}
}
return(Convert.ToBase64String(encrypted));
}
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);
}
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 string Encript(string input, string key)
{
byte[] rawInput = Encoding.UTF8.GetBytes(input); //pravimo niz bajtova od unetog stringa
byte[] encrypted; //pomocni niz u koga enkriptujemo
//pravimo kljuc za 3DES
byte[] byteKey = StringToByteArray(key);
byte[] buffer = new byte[4] {
0, 0, 0, 0
};
byte[] KeyFor3DES = new byte[byteKey.Length + buffer.Length];
System.Buffer.BlockCopy(byteKey, 0, KeyFor3DES, 0, byteKey.Length);
System.Buffer.BlockCopy(buffer, 0, KeyFor3DES, byteKey.Length, buffer.Length);
TripleDESCryptoServiceProvider tripleDesCrypto = new TripleDESCryptoServiceProvider
{
Key = KeyFor3DES,
Mode = CipherMode.CBC,
Padding = PaddingMode.None
};
//Mora sa ovim algoritmom, sa starim radi samo u ECB modu
tripleDesCrypto.GenerateIV();
ICryptoTransform tripleDesEncrypt = tripleDesCrypto.CreateEncryptor();
using (MemoryStream mStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(mStream, tripleDesEncrypt, CryptoStreamMode.Write))
{
cryptoStream.Write(rawInput, 0, rawInput.Length);
encrypted = tripleDesCrypto.IV.Concat(mStream.ToArray()).ToArray();
}
}
return(Convert.ToBase64String(encrypted));
}
} //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
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 byte[] GenTripleDesIV()
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.GenerateIV();
return(des.IV);
}
/// <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;
}
}
public string Encrypt(string input, string key)
{
byte[] rawInput = Encoding.UTF8.GetBytes(input); //pravimo niz bajtova od unetog stringa
byte[] encrypted; //pomocni niz u koga enkriptujemo
//pravimo kljuc za 3DES
byte[] KeyFor3DES = ASCIIEncoding.ASCII.GetBytes(key);
TripleDESCryptoServiceProvider tripleDesCrypto = new TripleDESCryptoServiceProvider
{
Key = KeyFor3DES,
Mode = CipherMode.CBC,
Padding = PaddingMode.None
};
tripleDesCrypto.GenerateIV();
ICryptoTransform tripleDesEncrypt = tripleDesCrypto.CreateEncryptor();
using (MemoryStream mStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(mStream, tripleDesEncrypt, CryptoStreamMode.Write))
{
cryptoStream.Write(rawInput, 0, rawInput.Length);
encrypted = tripleDesCrypto.IV.Concat(mStream.ToArray()).ToArray();
}
}
return(Convert.ToBase64String(encrypted));
}
/// <summary>
/// Encrypts bytes of data with password using self-generated IV.
/// </summary>
/// <param name="data">Data in bytes.</param>
/// <param name="password">Key/Password to encrypt.</param>
/// <param name="iv">Self-generated IV.</param>
/// <returns>Encrypted data in bytes. Returns null if encryption fails.</returns>
/// <exception cref="ArgumentNullException">'data' cannot be null/empty.</exception>
/// <exception cref="ArgumentNullException">'password' cannot be null/empty.</exception>
public byte[] Encrypt(byte[] data, string password, out byte[] iv)
{
iv = null;
if (data == null || data.Length == 0)
{
throw new ArgumentNullException(nameof(data));
}
if (String.IsNullOrEmpty(password))
{
throw new ArgumentNullException(nameof(password));
}
byte[] result = null;
using (TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider())
{
try
{
byte[] passwordBytes = BitHelpers.CreateSecurePassword(password, 24);
tdes.Key = passwordBytes;
tdes.GenerateIV();
iv = tdes.IV;
using (ICryptoTransform crypto = tdes.CreateEncryptor())
{
result = crypto.TransformFinalBlock(data, 0, data.Length);
}
}
catch { result = null; }
}
return(result);
}
public static byte[] Encrypt(string plain, string password, int keySize = 64)
{
TripleDESCryptoServiceProvider desProvider = new TripleDESCryptoServiceProvider();
desProvider.Mode = CipherMode.CBC;
desProvider.Padding = PaddingMode.PKCS7;
desProvider.KeySize = keySize;
desProvider.GenerateIV();
desProvider.Key = new PasswordDeriveBytes(password, new byte[] { }).GetBytes(desProvider.KeySize / 8);
byte[] plainBytes = System.Text.Encoding.UTF8.GetBytes(plain);
ICryptoTransform encrypter = desProvider.CreateEncryptor();
using (MemoryStream output = new MemoryStream())
using (CryptoStream writer = new CryptoStream(output, encrypter, CryptoStreamMode.Write))
{
writer.Write(plainBytes, 0, plainBytes.Length);
writer.FlushFinalBlock();
byte[] Encrypted = new byte[output.Length + desProvider.BlockSize / 8];
Buffer.BlockCopy(desProvider.IV, 0, Encrypted, 0, desProvider.IV.Length);
Buffer.BlockCopy(output.ToArray(), 0, Encrypted, desProvider.IV.Length, output.ToArray().Length);
return(Encrypted);
}
}
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 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[] TripleDESEncrypt(byte[] bytesData, out byte[] key)
{
TripleDES des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
// See if a key was provided
byte[] TripleDESKey = des3.Key;
des3.GenerateIV();
byte[] TripleDESinitVec = des3.IV;
MemoryStream memStreamEncryptedData = new MemoryStream();
ICryptoTransform transform = des3.CreateEncryptor();
CryptoStream encStream = new CryptoStream(memStreamEncryptedData, transform, CryptoStreamMode.Write);
try
{
//Encrypt the data, write it to the memory stream.
encStream.Write(bytesData, 0, bytesData.Length);
}
catch (Exception ex)
{
//oLib.LogError("Error while Encrypting Data: " + ex.Message, new System.Object());
throw new Exception("Error while Encrypting Data: \n" + ex.Message);
}
encStream.FlushFinalBlock();
encStream.Close();
key = TripleDESKey;
//Send the data back.
return(memStreamEncryptedData.ToArray());
}
public static byte[] sifrujCBC(string ulaznaRec, string kljuc)
{
MD5CryptoServiceProvider md = new MD5CryptoServiceProvider();
UTF8Encoding utf8 = new UTF8Encoding();
TripleDESCryptoServiceProvider tDES = new TripleDESCryptoServiceProvider();
tDES.Key = md.ComputeHash(utf8.GetBytes(kljuc));
tDES.Mode = CipherMode.CBC; //valjda moze ovako
tDES.Padding = PaddingMode.Zeros; //ovo nznm sta je
tDES.GenerateIV();
ICryptoTransform trans = tDES.CreateEncryptor();
byte[] sifrovano = trans.TransformFinalBlock(utf8.GetBytes(ulaznaRec), 0, utf8.GetBytes(ulaznaRec).Length);
//string ispis = BitConverter.ToString(sifrovano);
//Console.WriteLine("Sifrovan tekst: " + ispis);
byte[] newMess = new byte[sifrovano.Length + tDES.IV.Length];
for (int i = 0; i < newMess.Length; i++)
{
if (i < tDES.IV.Length)
{
newMess[i] = tDES.IV[i];
}
else
{
newMess[i] = sifrovano[i - tDES.IV.Length];
}
}
return(newMess);
}
/// <summary>
/// TripleDES算法构造函数（KEY自定义，IV随机生成）
/// </summary>
/// <param name="sKey"></param>
public TripleDES(string sKey)
{
des = new TripleDESCryptoServiceProvider();
des.GenerateIV();
Key = sKey;
IV = Convert.ToBase64String(des.IV);
}
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);
}
}
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 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);
}
public TripleDesHelper()
{
TripleDES = new TripleDESCryptoServiceProvider();
TripleDES.GenerateIV();
TripleDES.GenerateKey();
DesKey = Convert.ToBase64String(TripleDES.Key);
DesVector = Convert.ToBase64String(TripleDES.IV);
}
/// <summary>
/// Generar_Claves : función que genera el vector de inicialización y la clave de concatenación
/// para el algoritmo TripleDes
/// </summary>
/// <param name="iv">string por referencia donde se almacenara el valor del vector de inicialización</param>
/// <param name="key">string por referencia donde se almacenara el valor de la clave de concatenación</param>
private void Generar_Claves(ref string iv, ref string key)
{
TripleDESCryptoServiceProvider alg = new TripleDESCryptoServiceProvider();
alg.GenerateIV();
alg.GenerateKey();
iv = ASCIIEncoding.ASCII.GetString(alg.IV);
key = ASCIIEncoding.ASCII.GetString(alg.Key);
}
/// <summary>
/// Sifrovani dat 3DES
/// - v pripade, ze vstupni data nemaji validni format vyhazuje GopayException
/// </summary>
///
/// <param name="data">data</param>
/// <param name="secureKey">secureKey</param>
///
/// <returns>zasifrovana data</returns>
public static string Encrypt(string data, string secureKey)
{
// Vytvorime instanci 3DES algoritmu, nastavime parametry
TripleDESCryptoServiceProvider alg = new TripleDESCryptoServiceProvider();
alg.Padding = PaddingMode.Zeros;
alg.Mode = CipherMode.ECB;
alg.GenerateIV();
try {
alg.Key = new ASCIIEncoding().GetBytes(secureKey);
} catch (Exception ex) {
throw new GopayException(ex.ToString());
}
// Vytvorime encryptor
ICryptoTransform encryptor = alg.CreateEncryptor(alg.Key, alg.IV);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
StreamWriter sw = new StreamWriter(cs);
byte[] encryptedByte;
try {
sw.Write(data);
sw.Flush();
cs.FlushFinalBlock();
encryptedByte = new byte[ms.Length];
ms.Position = 0;
ms.Read(encryptedByte, 0, (int)ms.Length);
} catch (Exception ex) {
throw new GopayException(ex.ToString());
} finally {
ms.Close();
ms.Dispose();
cs.Close();
cs.Dispose();
sw.Close();
sw.Dispose();
}
StringBuilder encryptedData = new StringBuilder();
foreach (byte b in encryptedByte)
{
try {
encryptedData.Append(String.Format("{0:x2}", b));
} catch (Exception ex) {
throw new GopayException(ex.ToString());
}
}
return(encryptedData.ToString());
}
private void btnSimetricaReceptor_Click(object sender, EventArgs e)
{
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.GenerateIV();
tdes.GenerateKey();
txtSimetricaIVReceptor.Text = Convert.ToBase64String(tdes.IV);
txtSimetricaKeyReceptor.Text = Convert.ToBase64String(tdes.Key);
}
private string GetKey()
{
TripleDESCryptoServiceProvider crypto = new TripleDESCryptoServiceProvider();
crypto.GenerateIV();
crypto.GenerateKey();
byte[] key = crypto.Key;
return(Convert.ToBase64String(key));
}
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;
}
