public static string Encrypt(string toEncrypt, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
string key = (string)settingsReader.GetValue("search", typeof(string));
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
public static string Encrypt(string plainText )
{
string encrypted = null;
try
{
byte[] inputBytes = ASCIIEncoding.ASCII.GetBytes(plainText);
byte[] pwdhash = null;
MD5CryptoServiceProvider hashmd5;
//generate an MD5 hash from the password.
//a hash is a one way encryption meaning once you generate
//the hash, you cant derive the password back from it.
hashmd5 = new MD5CryptoServiceProvider();
pwdhash = hashmd5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(key));
hashmd5 = null;
// Create a new TripleDES service provider
TripleDESCryptoServiceProvider tdesProvider = new TripleDESCryptoServiceProvider();
tdesProvider.Key = pwdhash;
tdesProvider.Mode = CipherMode.ECB;
byte [] edata = tdesProvider.CreateEncryptor().TransformFinalBlock(inputBytes, 0, inputBytes.Length);
encrypted = Convert.ToBase64String( edata );
}
catch(Exception e)
{
string str = e.Message;
throw ;
}
return encrypted;
}
public string Encrypt(string ToEncrypt, bool useHasing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(ToEncrypt);
string Key = "malkit";
if (useHasing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(Key));
hashmd5.Clear();
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(Key);
}
TripleDESCryptoServiceProvider tDes = new TripleDESCryptoServiceProvider();
tDes.Key = keyArray;
tDes.Mode = CipherMode.ECB;
tDes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tDes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tDes.Clear();
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
//md5 encrypt
public static string MD5Encrypt(string toEncrypt, string securityKey, bool useHashing)
{
string retVal = string.Empty;
try {
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes (toEncrypt);
ValidateInput (toEncrypt);
ValidateInput (securityKey);
if (useHashing) {
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider ();
keyArray = hashmd5.ComputeHash (UTF8Encoding.UTF8.GetBytes (securityKey));
hashmd5.Clear ();
} else {
keyArray = UTF8Encoding.UTF8.GetBytes (securityKey);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider ();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor ();
byte[] resultArray = cTransform.TransformFinalBlock (toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear ();
retVal = Convert.ToBase64String (resultArray, 0, resultArray.Length);
} catch (Exception ex) {
Debug.Log (ex.Message);
}
return retVal;
}
public static byte[] Get3DesSignatureInBytes(byte[] data, byte[] sharedSecret)
{
HashAlgorithm hash = new SHA1Managed();
byte[] hashedData = hash.ComputeHash(data);
byte[] decryptedSignature = new byte[24];
for (int i = 0; i < hashedData.Length; i++)
{
decryptedSignature[i] = hashedData[i];
}
for (int i = 20; i < decryptedSignature.Length; i++)
{
decryptedSignature[i] = (byte)0xFF;
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = sharedSecret;
byte[] iv = new byte[8];
for (int i = 0; i < iv.Length; i++)
{
iv[i] = (byte)0x00;
}
tdes.IV = iv;
tdes.Mode = CipherMode.CBC;
ICryptoTransform transform = tdes.CreateEncryptor();
byte[] signature = new byte[24];
transform.TransformBlock(decryptedSignature, 0, decryptedSignature.Length, signature, 0);
return signature;
}
/// <summary>
/// 使用给定密钥加密
/// </summary>
/// <param name="original">明文</param>
/// <param name="key">密钥</param>
/// <returns>密文</returns>
public static byte[] Encrypt(byte[] original, byte[] key)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = MakeMD5(key);
des.Mode = CipherMode.ECB;
return des.CreateEncryptor().TransformFinalBlock(original, 0, original.Length);
}
public static string Encrypt(string input, string key)
{
byte[] inputArray = UTF8Encoding.UTF8.GetBytes(input);
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Key = UTF8Encoding.UTF8.GetBytes(key);
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tripleDES.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
tripleDES.Clear();
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
public string Encrypt(string key, string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
TripleDESCryptoServiceProvider tdes =
new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
/// <summary>
/// Encodes a stream of bytes using DES encryption with a pass key. Lowest level method that
/// handles all work.
/// </summary>
/// <param name="InputString"></param>
/// <param name="EncryptionKey"></param>
/// <returns></returns>
public static byte[] EncryptBytes(byte[] InputString, string EncryptionKey)
{
if (EncryptionKey == null)
EncryptionKey = strKey;
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
des.Key = hashmd5.ComputeHash(Encoding.ASCII.GetBytes(EncryptionKey));
des.Mode = CipherMode.ECB;
ICryptoTransform Transform = des.CreateEncryptor();
byte[] Buffer = InputString;
return Transform.TransformFinalBlock(Buffer, 0, Buffer.Length);
}
/// <summary>
/// TripleDes Data Encrypt Use IVKey Operator
/// </summary>
/// <param name="sourceContent">Source Content</param>
/// <param name="encryptKey">Encrypt Key</param>
/// <returns>Encrypt Bytes Array</returns>
public static byte[] TripleDesEncryptUseIvKey(string sourceContent, byte[] encryptIVKey)
{
if (string.IsNullOrEmpty(sourceContent) || encryptIVKey == null || encryptIVKey.Length <= 0)
return null;
var toEncryptSourceStr = Encoding.UTF8.GetBytes(sourceContent);
TripleDESCryptoServiceProvider tripleDesProvider = new TripleDESCryptoServiceProvider();
//No Seting Pading
var key = tripleDesProvider.Key; //Save Key
IsolatedStorageCommon.IsolatedStorageSettingHelper.AddIsolateStorageObj("EncryptKey", key);
ICryptoTransform encryptTransform = tripleDesProvider.CreateEncryptor(key, encryptIVKey);
var encryptBytes = encryptTransform.TransformFinalBlock(toEncryptSourceStr, 0, toEncryptSourceStr.Length);
return encryptBytes;
}
public string Encrypt(string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.BigEndianUnicode.GetBytes(toEncrypt);
bool useHashing = false;
//System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
// Get the key from config file
//string key = (string)settingsReader.GetValue("SecurityKey", typeof(String));
string key = "MPcrypto";
//System.Windows.Forms.MessageBox.Show(key);
//If hashing use get hashcode regards to your key
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.BigEndianUnicode.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.BigEndianUnicode.GetBytes(key);
TripleDESCryptoServiceProvider tdes =
new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resultArray =
cTransform.TransformFinalBlock(toEncryptArray, 0,
toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//Return the encrypted data into unreadable string format
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
public static string EncryptTripleDES(string phrase, string key, bool hashKey = true)
{
var keyArray = HexStringToByteArray(hashKey ? HashMD5(key) : key);
var toEncryptArray = Encoding.UTF8.GetBytes(phrase);
var tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
var cTransform = tdes.CreateEncryptor();
var resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return ByteArrayToHexString(resultArray);
}
/// <summary>
/// Encrypt the given string using the specified key.
/// </summary>
/// <param name="strToEncrypt">The string to be encrypted.</param>
/// <param name="strKey">The encryption key.</param>
/// <returns>The encrypted string.</returns>
public static string Encrypt(string strToEncrypt, string strKey)
{
try
{
TripleDESCryptoServiceProvider objDESCrypto = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider objHashMD5 = new MD5CryptoServiceProvider();
byte[] byteHash, byteBuff;
string strTempKey = strKey;
byteHash = objHashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(strTempKey));
objHashMD5 = null;
objDESCrypto.Key = byteHash;
objDESCrypto.Mode = CipherMode.ECB; //CBC, CFB
byteBuff = ASCIIEncoding.ASCII.GetBytes(strToEncrypt);
return Convert.ToBase64String(objDESCrypto.CreateEncryptor().
TransformFinalBlock(byteBuff, 0, byteBuff.Length));
}
catch (Exception ex)
{
return "Wrong Input. " + ex.Message;
}
}
public static string EncryptData(string Message, string passphrase)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(passphrase));
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
byte[] DataToEncrypt = UTF8.GetBytes(Message);
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return Convert.ToBase64String(Results);
}
public static void SetString(string key, string value)
{
// Hide '_key' string.
MD5 md5Hash = MD5.Create();
byte[] hashData = md5Hash.ComputeHash(System.Text.Encoding.UTF8.GetBytes(key));
string hashKey = System.Text.Encoding.UTF8.GetString(hashData);
// Encrypt '_value' into a byte array
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(value);
// Eecrypt '_value' with 3DES.
TripleDES des = new TripleDESCryptoServiceProvider();
des.Key = secret;
des.Mode = CipherMode.ECB;
ICryptoTransform xform = des.CreateEncryptor();
byte[] encrypted = xform.TransformFinalBlock(bytes, 0, bytes.Length);
// Convert encrypted array into a readable string.
string encryptedString = Convert.ToBase64String(encrypted);
// Set the ( key, encrypted value ) pair in regular PlayerPrefs.
PlayerPrefs.SetString(hashKey, encryptedString);
}
public static byte[] Encrypt(byte[] input)
{
return(Transform(input, _tripleDES.CreateEncryptor(Key, IV)));
}
/// <summary>
/// Método responsável por Criptografar um valor passado como parâmetro
/// </summary>
/// <param name="str">Valor a ser criptografado</param>
/// <returns>Valor criptografado</returns>
public static string Criptografar(string str)
{
// Verifico se foi informado um valor para criptografia
if (!string.IsNullOrEmpty(str))
{
// Vetor de bytes com a string informada
byte[] valor = Encoding.UTF8.GetBytes(str);
//Crio um algoritimo simétrico utilizando a implementação TripleDESCryptoServiceProvider
SymmetricAlgorithm algoritmoSimetrico = new TripleDESCryptoServiceProvider();
// ICryptoTransform=Interface que define as operações básicas de criptografia
// Substituo o membro CreateDecryptor da classe SymmetricAlgorithm
ICryptoTransform ct = algoritmoSimetrico.CreateEncryptor(chave, iv);
// Crio um MemoryStream que encapsula dados armazenados como uma matriz de bytes
MemoryStream fluxoMemoria = new MemoryStream();
// Define um fluxo que transmite dados para transformações de criptografia
CryptoStream fluxoCriptografia = new CryptoStream(fluxoMemoria, ct, CryptoStreamMode.Write);
// Caso ocorra alguma exceção o objeto CryptoStream não poderá ser fechado,
//por isso, utilizo o bloco try/catch para garantir que o objeto será fechado
try
{
fluxoCriptografia.Write(valor, 0, valor.Length);
fluxoCriptografia.FlushFinalBlock();
// Fecho o objeto CryptoStream explicitamente para liberar o fluxo
fluxoCriptografia.Close();
}
catch
{
// Garanto que o objeto será fechado caso ocorra alguma exceção
if (fluxoCriptografia != null) { fluxoCriptografia.Close(); }
}
// Retorno o valor criptografado
return Convert.ToBase64String(fluxoMemoria.ToArray());
}
else
{
// Retorno uma string vazia
return string.Empty;
}
}
public string[] ECBPlaintoCipher(string[] plain, string key, bool auto = true)//تبدیل متن به کد
{
List <BitArray> Cipherlb = new List <BitArray>();
string[] Cipher = new string[plain.Length];
byte[] keyArray;
byte[] toEncryptArray;
int i = 0;
string k = key;
int m = 1;
if (k.Length != 0)
{
if (k.Length > 24)
{
k = (k.Substring(k.Length - 1) + k).Substring(0, 24);
}
else if (k.Length < 24)
{
for (int j = k.Length; j < 24; j++)
{
if (m == 1)
{
k += "a"; m++;
}
else if (m == 2)
{
k += "b"; m++;
}
else if (m == 3)
{
k += "c"; m++;
}
else if (m == 4)
{
k += "d"; m++;
}
else
{
k += "e"; m = 1;
}
}
}
}
//
foreach (var item in plain)
{
toEncryptArray = UTF8Encoding.UTF8.GetBytes(item);
if (auto)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(k));
hashmd5.Clear();
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(k);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock
(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
Cipher[i++] = Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
return(Cipher);
}
public string EncryptString(string plainText)
{
return(Transform(plainText, _provider.CreateEncryptor(_key, _iv)));
}
internal ICryptoTransform GetServiceProvider(byte[] Key, byte[] IV)
{
ICryptoTransform cryptoTransform = null;
ICryptoTransform result;
switch (algorithm)
{
case CryptoProvider.DES:
{
DESCryptoServiceProvider dESCryptoServiceProvider = new DESCryptoServiceProvider();
CryptoAction cryptoAction = cAction;
if (cryptoAction != CryptoAction.Encrypt)
{
if (cryptoAction == CryptoAction.Desencrypt)
{
cryptoTransform = dESCryptoServiceProvider.CreateDecryptor(Key, IV);
}
}
else
{
cryptoTransform = dESCryptoServiceProvider.CreateEncryptor(Key, IV);
}
result = cryptoTransform;
break;
}
case CryptoProvider.TripleDES:
{
TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
CryptoAction cryptoAction2 = cAction;
if (cryptoAction2 != CryptoAction.Encrypt)
{
if (cryptoAction2 == CryptoAction.Desencrypt)
{
cryptoTransform = tripleDESCryptoServiceProvider.CreateDecryptor(Key, IV);
}
}
else
{
cryptoTransform = tripleDESCryptoServiceProvider.CreateEncryptor(Key, IV);
}
result = cryptoTransform;
break;
}
case CryptoProvider.RC2:
{
RC2CryptoServiceProvider rC2CryptoServiceProvider = new RC2CryptoServiceProvider();
CryptoAction cryptoAction3 = cAction;
if (cryptoAction3 != CryptoAction.Encrypt)
{
if (cryptoAction3 == CryptoAction.Desencrypt)
{
cryptoTransform = rC2CryptoServiceProvider.CreateDecryptor(Key, IV);
}
}
else
{
cryptoTransform = rC2CryptoServiceProvider.CreateEncryptor(Key, IV);
}
result = cryptoTransform;
break;
}
case CryptoProvider.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
CryptoAction cryptoAction4 = cAction;
if (cryptoAction4 != CryptoAction.Encrypt)
{
if (cryptoAction4 == CryptoAction.Desencrypt)
{
cryptoTransform = rijndael.CreateDecryptor(Key, IV);
}
}
else
{
cryptoTransform = rijndael.CreateEncryptor(Key, IV);
}
result = cryptoTransform;
break;
}
default:
throw new CryptographicException("Error al inicializar al proveedor de cifrado");
}
return(result);
}
private void BtnRegistrar_Click(object sender, EventArgs e)
{
//================= Validar campos vacios =====================
bool campos = true;
if (txtApellidos.Text == string.Empty ||
txtNombres.Text == string.Empty ||
txtDireccion.Text == string.Empty ||
txtCorreo.Text == string.Empty ||
txtDNI.Text == string.Empty ||
txtContraseña1.Text == string.Empty ||
txtContraseña2.Text == string.Empty ||
txtCelular.Text == string.Empty)
{
campos = false;
}
else
{
campos = true;
}
//====================== Encriptando Contraseña ==========================
string contraseña;
string hash = "Gim@5i0";
byte[] data = UTF8Encoding.UTF8.GetBytes(txtContraseña1.Text);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
using (TripleDESCryptoServiceProvider Tripdes = new TripleDESCryptoServiceProvider()
{
Key = keys, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
})
{
ICryptoTransform transform = Tripdes.CreateEncryptor();
byte[] resultados = transform.TransformFinalBlock(data, 0, data.Length);
contraseña = Convert.ToBase64String(resultados, 0, resultados.Length);
}
}
// ==================================================================================
// ======================== Relizando registro de empleado ============================
if (txtContraseña1.Text != txtContraseña2.Text)
{
MessageBox.Show("Las contraseñas no coinciden", "No se pudo completa la operación", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else if (campos == false)
{
MessageBox.Show("Todos los campos son obligatorios", "No se pudo completa la operación", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
DialogResult pregunta = MessageBox.Show("Desea Registrar al nuevo empleado", "Aviso", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
if (pregunta == DialogResult.Yes)
{
Empleado empleado = new Empleado(0, txtNombres.Text, txtApellidos.Text, txtDNI.Text, txtDireccion.Text, txtCelular.Text, contraseña, txtCorreo.Text, null);
NEmpleado Negocio = new NEmpleado();
bool rpsta = Negocio.NuevoEmpleado(empleado);
if (rpsta == true)
{
MessageBox.Show("Empleado Registrado", "Realizado", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show("Asegurese que el Dni ingresado no este ya regitrado", "Error en el registro", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
//============ Limpiar cuadros de texto ==================
config.limpiarTextbox(this.Controls);
//=========================================================
}
}
// ==============================================================================================================
}
public void FileEncryptDES(string inputFile, string passwordPlain)
{
TripleDESCryptoServiceProvider desCryptoProvider = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashMD5Provider = new MD5CryptoServiceProvider();
byte[] byteHash;
byte[] byteBuff;
byte[] desIVKey = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
byteHash = hashMD5Provider.ComputeHash(Encoding.UTF8.GetBytes(passwordPlain));
desCryptoProvider.Key = byteHash;
desCryptoProvider.Mode = CipherMode.CBC;
desCryptoProvider.IV = desIVKey;
byteBuff = File.ReadAllBytes(inputFile);
File.WriteAllBytes(filePath.Substring(0, filePath.Length - 4) + "_encrypted_DES.txt", desCryptoProvider.CreateEncryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length));
AddMAC(filePath.Substring(0, filePath.Length - 4) + "_encrypted_DES.txt", passwordPlain);
}
static void Main(string[] args)
{
const int n = 100 * 1000;
var sw = new Stopwatch();
Random r = new Random();
var data = new byte[1024];
var key8B = new byte[8];
var key16B = new byte[16];
var key24B = new byte[24];
var key32B = new byte[32];
r.NextBytes(data);
r.NextBytes(key8B);
r.NextBytes(key16B);
r.NextBytes(key24B);
r.NextBytes(key32B);
Action <string> outputToConsole = (s) =>
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine(s);
};
// AES
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("AES");
var aes = new AesCryptoServiceProvider();
aes.Padding = PaddingMode.PKCS7;
aes.Key = key16B;
Action doAes = () => EncryptDecryptAndDispose(aes.CreateEncryptor(), aes.CreateDecryptor(), data);
doAes.Repeat(n)
.OutputPerformance(sw, outputToConsole)();
aes.Dispose();
// RSA
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("DES");
var des = new DESCryptoServiceProvider();
des.IV = key8B;
des.Key = key8B;
Action doDes = () => EncryptDecryptAndDispose(des.CreateEncryptor(), des.CreateDecryptor(), data);
doDes.Repeat(n)
.OutputPerformance(sw, outputToConsole)();
des.Dispose();
// RC2
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("RC2");
var rc2 = new RC2CryptoServiceProvider();
rc2.IV = key8B;
rc2.Key = key8B;
Action doRc2 = () => EncryptDecryptAndDispose(rc2.CreateEncryptor(), rc2.CreateDecryptor(), data);
doRc2.Repeat(n)
.OutputPerformance(sw, outputToConsole)();
rc2.Dispose();
// Rijndael
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("Rijndael");
var rijndael = new RijndaelManaged();
rijndael.IV = key16B;
rijndael.Key = key16B;
Action doRijndael = () => EncryptDecryptAndDispose(rijndael.CreateEncryptor(), rijndael.CreateDecryptor(), data);
doRijndael.Repeat(n)
.OutputPerformance(sw, outputToConsole)();
rijndael.Dispose();
// 3DES
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("3DES");
var tripleDes = new TripleDESCryptoServiceProvider();
tripleDes.IV = key8B;
tripleDes.Key = key24B;
Action do3des = () => EncryptDecryptAndDispose(tripleDes.CreateEncryptor(), tripleDes.CreateDecryptor(), data);
do3des.Repeat(n)
.OutputPerformance(sw, outputToConsole)();
tripleDes.Dispose();
// RSA
Console.ForegroundColor = ConsoleColor.DarkCyan;
Console.WriteLine("RSA");
RSAParameters param = new RSAParameters();
param.Exponent = new byte[] { 0, 1, 0 };
var store = new X509Store(StoreLocation.LocalMachine);
store.Open(OpenFlags.ReadOnly);
X509Certificate cert = null;
foreach (X509Certificate cer in store.Certificates)
{
if (cer != null)
{
cert = cer;
break;
}
}
param.Modulus = cert.GetPublicKey();
var rsa = new RSACryptoServiceProvider();
rsa.ImportParameters(param);
Action doRsa = () =>
{
var encryptedData = rsa.Encrypt(key32B, true);
//var decryptedData = rsa.Decrypt(encryptedData, true);
};
doRsa.Repeat(n)
.OutputPerformance(sw, outputToConsole)();
rsa.Dispose();
Console.Read();
}
protected void CreateUser_Click(object sender, EventArgs e)
{
//declares a couple string variables that we'll use when checking the DB if the user already exists
string userLastName = LastName.Text;
string userFirstName = FirstName.Text;
string userName = UserName.Text;
//method that checks the DB using first and last name
this.GetUser(userFirstName, userLastName, userName);
if (DBUser == null)
{
DBUser = new User(); //creates user object
//adds registration data into the DB as a new user
this.PutCustomerData(DBUser);
try
{
DBUser.ID = UserDB.AddUser(DBUser);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.GetType().ToString());
}
}
else
{
//user exists already
MessageBox.Show("First and Last Name Have Already Been Taken Or Else The UserName's Been Taken");
return; //user exists so cancel registering and return to page
}
//variables from template that store new user into local DB located in the App_Data folder
var manager = Context.GetOwinContext().GetUserManager <ApplicationUserManager>();
var signInManager = Context.GetOwinContext().Get <ApplicationSignInManager>();
var user = new ApplicationUser()
{
UserName = UserName.Text, Email = UserName.Text
};
IdentityResult result = manager.Create(user, Password.Text);
//logs into the DB
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=320771
//string code = manager.GenerateEmailConfirmationToken(user.Id);
//string callbackUrl = IdentityHelper.GetUserConfirmationRedirectUrl(code, user.Id, Request);
//manager.SendEmail(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>.");
signInManager.SignIn(user, isPersistent: false, rememberBrowser: false);
IdentityHelper.RedirectToReturnUrl(Request.QueryString["ReturnUrl"], Response);
}
//catches any other errors
else
{
ErrorMessage.Text = result.Errors.FirstOrDefault();
}
//encrypts the password
byte[] data = UTF8Encoding.UTF8.GetBytes(Password.Text);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] key = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
using (TripleDESCryptoServiceProvider tripleDES =
new TripleDESCryptoServiceProvider()
{
Key = key,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
}
)
{
ICryptoTransform transform = tripleDES.CreateEncryptor();
//byte[] result = transform.TransformFinalBlock(data, 0, data.Length);
//txtEncrypted.Text = Convert.ToBase64String(result, 0, result.Length);
}
}
}
private void btnSubmit_Click(object sender, RoutedEventArgs e)
{
string hash = "kcuf@BV";
byte[] data = UTF8Encoding.UTF8.GetBytes(txtPassword.Password);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
using (TripleDESCryptoServiceProvider tripDes = new TripleDESCryptoServiceProvider()
{
Key = keys, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
})
{
ICryptoTransform transform = tripDes.CreateEncryptor();
Byte[] results = transform.TransformFinalBlock(data, 0, data.Length);
txtPassword.Password = Convert.ToBase64String(results, 0, results.Length);
}
}
using (MagazijnEntities ctx = new MagazijnEntities())
{
var geselecteerdeGebruiker = ctx.PersoneelsIDs.Where(x => x.Username == txtUsername.Text && x.Wachtwoord == txtPassword.Password).Count();
var loging = ctx.PersoneelsIDs.Where(x => x.Username == txtUsername.Text).Select(x => x.Wachtwoord).Count();
//var wachtwoord = ctx.PersoneelsIDs.Where(x => x.Username == txtUsername.Text).Select(x => x.Wachtwoord).FirstOrDefault().ToString();
if (geselecteerdeGebruiker == 1)
{
string username = txtUsername.Text;
txtPassword.Clear();
txtUsername.Clear();
//MessageBox.Show("Gebruiker naam gevonden and pass: "******"Gebruiker naam niet gevonden xxxxxxxxxxxx");
txtPassword.Clear();
txtUsername.Clear();
}
// var wachtwoord = ctx.PersoneelsIDs.Where(x => x.Username == txtUsername.Text).Select(x => x.Wachtwoord).FirstOrDefault().ToString();
// byte[] data = Convert.FromBase64String(wachtwoord);
//using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
//{
// byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
// using (TripleDESCryptoServiceProvider tripDes = new TripleDESCryptoServiceProvider() { Key = keys, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 })
// {
// ICryptoTransform transform = tripDes.CreateDecryptor();
// Byte[] results = transform.TransformFinalBlock(data, 0, data.Length);
// wachtwoord = UTF32Encoding.UTF8.GetString(results);
// //MessageBox.Show(wachtwoord);
// }
//}
}
//if (wachtwoord == txtPassword.Password)
//{
// string username = txtUsername.Text;
// txtPassword.Clear();
// txtUsername.Clear();
// //MessageBox.Show("Gebruiker naam gevonden and pass: "******"Gebruiker naam niet gevonden xxxxxxxxxxxx");
//}
}
internal static bool EncryptFile(string fileNameToEncrypt)
{
string encryptedFileName = fileNameToEncrypt + ".enc";
//instantiate our RSA crypto service provider with parameters
const int PROVIDER_RSA_FULL = 1;
const string CONTAINER_NAME = "CodewordCryptoContainer";
CspParameters cspParams;
cspParams = new CspParameters(PROVIDER_RSA_FULL);
cspParams.KeyContainerName = CONTAINER_NAME;
cspParams.Flags = CspProviderFlags.UseMachineKeyStore;
cspParams.ProviderName = "Microsoft Strong Cryptographic Provider";
RSACryptoServiceProvider aSymmetricEncProvider = new RSACryptoServiceProvider(cspParams);
TripleDESCryptoServiceProvider SymmetricEncProvider = new TripleDESCryptoServiceProvider();
//open read-only file stream for our unencrypted file
FileStream PlaintextFileDataStream = new FileStream(fileNameToEncrypt, System.IO.FileMode.Open, System.IO.FileAccess.Read);
//create a writable filestream to write encrypted file out
FileStream EncryptedFileDataStream = new FileStream(encryptedFileName, System.IO.FileMode.Create, System.IO.FileAccess.Write);
//init a binaryWriter class to dump data to file
BinaryWriter bw = new BinaryWriter(EncryptedFileDataStream);
int fileLength = (int)PlaintextFileDataStream.Length;
//if no data to encrypt, fail now
if (fileLength == 0)
{
PlaintextFileDataStream.Close();
EncryptedFileDataStream.Close();
return(false);
}
//read all data from file as binary data
byte[] UnencryptedBinaryData = ReadByteArray(PlaintextFileDataStream);
PlaintextFileDataStream.Close();
//generate a new IV and sym key for encryption
SymmetricEncProvider.GenerateIV();
SymmetricEncProvider.GenerateKey();
//use asymmetric encryption to encrpyt initialization vector (IV)
byte[] EncryptedBinaryData = aSymmetricEncProvider.Encrypt(SymmetricEncProvider.IV, false);
//then write it to the output stream (encrypted file)
bw.Write(EncryptedBinaryData);
//do the same for symmetric key
EncryptedBinaryData = aSymmetricEncProvider.Encrypt(SymmetricEncProvider.Key, false);
bw.Write(EncryptedBinaryData);
//create our symmetric encryptor
ICryptoTransform DES3Encrypt = SymmetricEncProvider.CreateEncryptor();
//create a crypto stream to write our encrypted data by using:
// -target data stream (EncryptedFileDataStream), ie output file encrypted
// -transformation to user (3-DES)
// -mode (Write)
//this will essentially pipe all our unencrypted data we read in from the file-to-encrypt
//through our encrypted data stream using the 3-DES transformation
CryptoStream cryptoStream = new CryptoStream(EncryptedFileDataStream, DES3Encrypt, CryptoStreamMode.Write);
cryptoStream.Write(UnencryptedBinaryData, 0, UnencryptedBinaryData.Length);
cryptoStream.Close();
EncryptedFileDataStream.Close();
PlaintextFileDataStream.Close();
bw.Close();
return(true);
}
public static void Crypt(string file, byte[] key, byte[] iv, bool encrypt = true, string algorithm = "aes")
{
if (!File.Exists(file))
{
throw new FileNotFoundException(file);
}
AesCryptoServiceProvider aes = null;
DESCryptoServiceProvider des = null;
TripleDESCryptoServiceProvider tripsDes = null;
ICryptoTransform cryptor;
switch (algorithm.ToLower())
{
case "aes":
aes = new AesCryptoServiceProvider();
aes.Key = key;
aes.IV = iv;
aes.Padding = PaddingMode.None;
if (encrypt)
{
cryptor = aes.CreateEncryptor();
}
else
{
cryptor = aes.CreateDecryptor();
}
break;
case "des":
des = new DESCryptoServiceProvider();
des.Key = key;
des.IV = iv;
des.Padding = PaddingMode.None;
if (encrypt)
{
cryptor = des.CreateEncryptor();
}
else
{
cryptor = des.CreateDecryptor();
}
break;
case "tripledes":
tripsDes = new TripleDESCryptoServiceProvider();
tripsDes.Key = key;
tripsDes.IV = iv;
tripsDes.Padding = PaddingMode.None;
if (encrypt)
{
cryptor = tripsDes.CreateEncryptor();
}
else
{
cryptor = tripsDes.CreateDecryptor();
}
break;
default:
throw new ArgumentException(algorithm + " is not an implemented encryption algorithm. Use AES/DES/TripleDES.");
}
CryptoStreamMode mode;
if (encrypt)
{
mode = CryptoStreamMode.Write;
}
else
{
mode = CryptoStreamMode.Read;
}
Random r = new Random();
string newFilename = file;
while (File.Exists(newFilename + ".tmp"))
{
newFilename += r.Next(0, 999999);
}
newFilename += ".tmp";
using (FileStream input = new FileStream(file, FileMode.Open), output = new FileStream(newFilename, FileMode.Create))
{
CryptoStream cs;
if (encrypt)
{
cs = new CryptoStream(output, cryptor, mode);
}
else
{
cs = new CryptoStream(input, cryptor, mode);
}
try
{
if (encrypt)
{
input.CopyTo(cs);
}
else
{
cs.CopyTo(output);
}
}
catch (CryptographicException)
{
throw new ArgumentException("Ensure you have the right key/IV.");
}
finally
{
cs.Flush();
cs.Dispose();
}
}
File.Delete(file);
File.Move(newFilename, file);
}
public static string Encrypt(string message, string key, bool useHashing)
{
if (string.IsNullOrEmpty(message) || string.IsNullOrEmpty(key))
{
return(string.Empty);
}
try
{
byte[] keyArray;
var toEncryptArray = Encoding.UTF8.GetBytes(message);
//Validate the array to encrypt
if (toEncryptArray.Length <= 0)
{
return(string.Empty);
}
if (useHashing)
{
var hashmd5 = new MD5CryptoServiceProvider();
var tmpArray = Encoding.UTF8.GetBytes(key);
if (tmpArray.Length <= 0)
{
return(string.Empty);
}
keyArray = hashmd5.ComputeHash(tmpArray);
}
else
{
keyArray = Encoding.UTF8.GetBytes(key);
}
//Validate key array
if (keyArray == null || keyArray.Length <= 0)
{
return(string.Empty);
}
var tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
var cTransform = tdes.CreateEncryptor();
var resultArray = cTransform.TransformFinalBlock(toEncryptArray,
0,
toEncryptArray.Length);
//Validate result array
if (resultArray == null || resultArray.Length <= 0)
{
return(string.Empty);
}
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
catch (System.Exception)
{
return(string.Empty);
}
}
public static byte[] TransformBuffer(byte[] buffer, bool decrypt = true, bool fdf1 = false, int type = 2)
{
TripleDESCryptoServiceProvider cryptoServiceProvider = new TripleDESCryptoServiceProvider();
cryptoServiceProvider.Key = fdf1 ? FDFOldKeys[type] : FDFSteamKeys[type];
cryptoServiceProvider.Mode = CipherMode.ECB;
ICryptoTransform decryptor = decrypt ? cryptoServiceProvider.CreateDecryptor() : cryptoServiceProvider.CreateEncryptor();
return(decryptor.TransformFinalBlock(buffer, 0, buffer.Length));
}
public static bool EncryptFile(string inFPath, string outFPath, string keyFPath, int keySize = keyMaxSize)
{
try
{
// key is in Unicode form
byte[] keyB = File.ReadAllBytes(keyFPath);
//Create the file streams to handle the input and output files.
FileStream fin = new FileStream(inFPath, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFPath, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
//Console.WriteLine("hhhh");
// generate a random salt, random number of iteration
//byte[] saltBytes = new byte[8];
//using ( RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider() )
//{
// // Fill the array with a random value.
// rngCsp.GetBytes(saltBytes);
//}
//int numOfIter = ( new Random() ).Next(1000, 2000);
var key = new Rfc2898DeriveBytes(keyB, saltBytes, numOfIter);
//
TripleDESCryptoServiceProvider tDes = new TripleDESCryptoServiceProvider()
{
KeySize = keySize
};
//tDes.BlockSize = 64;
// blockSizeBytes can take any arbitrary number
int blockSizeBytes = 4096; //tDes.BlockSize / 8;
tDes.Key = key.GetBytes(tDes.KeySize / 8); // same salt, same password, same number of iteration
//tDes.IV = key.GetBytes(tDes.BlockSize / 8); // lead to same pair of key and IV
// so must randomize the IV for each time of encryption
//using (RNGCryptoServiceProvider rngCsp = new RNGCryptoServiceProvider())
//{
// // Fill the array with a random value.
// rngCsp.GetBytes(tDes.IV);
//}
// Write the following to the FileStream
// for the encrypted file (outFs):
// - the IV
// - the encrypted cipher content
//Console.WriteLine("hhh");
fout.Write(tDes.IV, 0, IVsize);
//foreach (byte h in tDes.IV)
//{
// Console.Write(h);
//}
//Console.WriteLine();
//foreach (byte h in tDes.Key)
//{
// Console.Write(h);
//}
//Console.WriteLine();
//Create variables to help with read and write.
byte[] bin = new byte[blockSizeBytes]; //This is intermediate storage for the encryption.
long rdlen = 0; //This is the total number of bytes written.
long totlen = fin.Length; //This is the total length of the input file.
int len; //This is the number of bytes to be written at a time.
// Now write the cipher text using
// a CryptoStream for encrypting.
CryptoStream encStream = new CryptoStream(fout, tDes.CreateEncryptor(), CryptoStreamMode.Write);
//Console.WriteLine("Encrypting...");
//Read from the input file, then encrypt and write to the output file.
while (rdlen < totlen)
{
len = fin.Read(bin, 0, blockSizeBytes);
encStream.Write(bin, 0, len);
rdlen += len;
//Console.WriteLine("{0} bytes processed", rdlen);
}
fin.Close();
//encStream.FlushFinalBlock();
encStream.Close();
fout.Close();
//Console.WriteLine("hhh");
return(true);
}
catch (CryptographicException e)
{
Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
return(false);
}
catch (UnauthorizedAccessException e)
{
Console.WriteLine("A file access error occurred: {0}", e.Message);
return(false);
}
catch (Exception)
{
throw;
}
}
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;
}
public string Encrypt(string SrcStr)
{
string encrypted;
TripleDESCryptoServiceProvider des;
MD5CryptoServiceProvider hashmd5;
byte[] pwdhash, buff;
//generate an MD5 hash from the m_Password.
//a hash is a one way encryption meaning once you generate
//the hash, you cant derive the m_Password back from it.
hashmd5 = new MD5CryptoServiceProvider();
pwdhash = hashmd5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(m_Password));
hashmd5 = null;
//implement DES3 encryption
des = new TripleDESCryptoServiceProvider();
//the key is the secret m_Password hash.
des.Key = pwdhash;
//the mode is the block cipher mode which is basically the
//details of how the encryption will work. There are several
//kinds of ciphers available in DES3 and they all have benefits
//and drawbacks. Here the Electronic Codebook cipher is used
//which means that a given bit of text is always encrypted
//exactly the same when the same m_Password is used.
des.Mode = CipherMode.ECB; //CBC, CFB
//----- encrypt an un-encrypted string ------------
//the SrcStr string, which needs encrypted, must be in byte
//array form to work with the des3 class. everything will because
//most encryption works at the byte level so you'll find that
//the class takes in byte arrays and returns byte arrays and
//you'll be converting those arrays to strings.
buff = ASCIIEncoding.ASCII.GetBytes(SrcStr);
//encrypt the byte buffer representation of the SrcStr string
//and base64 encode the encrypted string. the reason the encrypted
//bytes are being base64 encoded as a string is the encryption will
//have created some weird characters in there. Base64 encoding
//provides a platform independent view of the encrypted string
//and can be sent as a plain text string to wherever.
encrypted = Convert.ToBase64String(des.CreateEncryptor().TransformFinalBlock(buff, 0, buff.Length));
//cleanup
des = null;
return encrypted;
}
/// <summary>
/// Define un objeto para la operaciones básicas de transformaciones
/// criptográficas.
/// </summary>
/// <param name="Key">Clave de encripción.</param>
/// <param name="IV">Vector de inicialización.</param>
/// <returns>Devuelve el objeto que implementa la interfaz ICryptoTransform.
/// </returns>
internal ICryptoTransform GetServiceProvider(byte[] Key, byte[] IV)
{
// creamos la variable que contendrá al objeto ICryptoTransform.
ICryptoTransform transform = null;
// dependiendo del algoritmo seleccionado, se devuelve el objeto adecuado.
switch (this.algorithm)
{
// Algoritmo DES.
case CryptoProvider.DES:
// dependiendo de la acción a realizar.
// creamos el objeto adecuado.
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
switch (cAction)
{
case CryptoAction.Encrypt: // si estamos cifrando,
// creamos el objeto cifrador.
transform = des.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt: // sí estamos descifrando,
// creamos el objeto descifrador.
transform = des.CreateDecryptor(Key, IV);
break;
}
// devolvemos el objeto transform correspondiente.
return(transform);
// algoritmo TripleDES.
case CryptoProvider.TripleDES:
TripleDESCryptoServiceProvider des3 = new TripleDESCryptoServiceProvider();
switch (cAction)
{
case CryptoAction.Encrypt:
transform = des3.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt:
transform = des3.CreateDecryptor(Key, IV);
break;
}
return(transform);
// algoritmo RC2.
case CryptoProvider.RC2:
RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider();
switch (cAction)
{
case CryptoAction.Encrypt:
transform = rc2.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt:
transform = rc2.CreateDecryptor(Key, IV);
break;
}
return(transform);
// algoritmo Rijndael.
case CryptoProvider.Rijndael:
Rijndael rijndael = new RijndaelManaged();
switch (cAction)
{
case CryptoAction.Encrypt:
transform = rijndael.CreateEncryptor(Key, IV);
break;
case CryptoAction.Desencrypt:
transform = rijndael.CreateDecryptor(Key, IV);
break;
}
return(transform);
default:
// en caso que no exista el proveedor seleccionado, generamos
// una excepción para informarlo.
throw new CryptographicException("Error al inicializar al proveedor de cifrado");
}
}
private void EncryptFile(string path, string key)
{
byte[] plainContent = System.IO.File.ReadAllBytes(path);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
using (TripleDESCryptoServiceProvider tripDes = new TripleDESCryptoServiceProvider())
{
tripDes.Key = keys;
switch ((Settings.Default.Cipher_Mode))
{
case 0:
tripDes.Mode = CipherMode.ECB;
break;
case 1:
tripDes.Mode = CipherMode.CFB;
break;
case 2:
tripDes.Mode = CipherMode.CBC;
break;
case 3:
tripDes.Mode = CipherMode.CTS;
break;
default:
tripDes.Mode = CipherMode.OFB;
break;
}
switch (Settings.Default.Padding_Mode)
{
case 0:
tripDes.Padding = PaddingMode.PKCS7;
break;
case 1:
tripDes.Padding = PaddingMode.ANSIX923;
break;
case 2:
tripDes.Padding = PaddingMode.ISO10126;
break;
default:
tripDes.Padding = PaddingMode.Zeros;
break;
}
using (var memStream = new System.IO.MemoryStream())
{
CryptoStream cryptoStream = new CryptoStream(memStream, tripDes.CreateEncryptor(), CryptoStreamMode.Write);
cryptoStream.Write(plainContent, 0, plainContent.Length);
cryptoStream.FlushFinalBlock();
System.IO.File.WriteAllBytes(path, memStream.ToArray());
//MessageBox.Show("Encrypt Successfully " + path, "Complete", MessageBoxButton.OK, MessageBoxImage.Information);
cryptoStream.Dispose();
memStream.Dispose();
cryptoStream.Close();
memStream.Close();
}
}
}
}
// Method for Encrypt
public bool Encrypt(string txt, string typeOfEncryption)
{
// Create object DateTime.Now
DateTime dt = new DateTime();
dt = DateTime.Now;
try
{
StringBuilder objStreamBuilder1 = new StringBuilder();
// Adds Date and Time now to text
objStreamBuilder1.Append(DateTime.Now.ToString());
// Adds Random Text to text
objStreamBuilder1.Append(GenerateRandomText());
// masterKey = DateTime + Random Text
this.text = txt + "Ñ" + objStreamBuilder1.ToString();
// Array where we store the key for encryption 3DES.
byte[] key;
// Array where we save the string encrypted.
byte[] array = UTF8Encoding.UTF8.GetBytes(text);
// We encrypt using the algorithm MD5.
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
key = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(masterKeyPassword));
md5.Clear();
// We encrypt using the algorithm 3DES.
TripleDESCryptoServiceProvider objTripleDes = new TripleDESCryptoServiceProvider();
objTripleDes.Key = key;
objTripleDes.Mode = CipherMode.ECB;
objTripleDes.Padding = PaddingMode.PKCS7;
// We began the conversion of the string.
ICryptoTransform convertir = objTripleDes.CreateEncryptor();
//Array of bytes where we save the string encrypted.
byte[] result = convertir.TransformFinalBlock(array, 0, array.Length);
objTripleDes.Clear();
StringBuilder objStreamBuilder2 = new StringBuilder();
// We convert the string.
objStreamBuilder2.AppendLine(Convert.ToBase64String(result, 0, result.Length) + "Ñ");
///ONLY for encrypt MasterKey
if (typeOfEncryption == "MasterKey")
{
// Adds Footer Text not encrypted to MasterKey Encrypted
objStreamBuilder2.AppendLine("");
objStreamBuilder2.AppendLine("");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# This is a MasterKey of SD - Secure Data software");
objStreamBuilder2.AppendLine("# Generated on: " + dt.ToString("MMM d, yyyy") + " at " + dt.ToString("H:mm:ss") + " Hs.");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# VERY IMPORTANT: DO NOT MODIFY THE CONTENTS OF THIS FILE!!!");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# About the SD - Secure Data software:");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# Created by Juan Pablo Torrellas on July 6, 2015.");
objStreamBuilder2.AppendLine("# E-mail: [email protected]");
objStreamBuilder2.AppendLine("# Copyright (c) 2015 Juan Pablo Torrellas. All rights reserved.");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("##################################################################");
this.text = objStreamBuilder2.ToString();
}
///ONLY for encrypt Text of textBoxText
if (typeOfEncryption == "Text")
{
if (textBoxText.Text == "")
{
objStreamBuilder2.Clear();
return(false);
}
else
{
buttonGo.Enabled = false;
buttonCopy.Enabled = true;
buttonPaste.Enabled = false;
buttonSaveAs.Enabled = true;
textBoxText.ReadOnly = true;
// Adds Footer Text not encrypted to TextEncrypted
objStreamBuilder2.AppendLine("");
objStreamBuilder2.AppendLine("");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# This is an encrypted text of SD - Secure Data software");
objStreamBuilder2.AppendLine("# Generated on: " + dt.ToString("MMM d, yyyy") + " at " + dt.ToString("H:mm:ss") + " Hs.");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# VERY IMPORTANT: DO NOT MODIFY THE CONTENTS OF THIS FILE!!!");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("##################################################################");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# About the SD - Secure Data software:");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("# Created by Juan Pablo Torrellas on July 6, 2015.");
objStreamBuilder2.AppendLine("# E-mail: [email protected]");
objStreamBuilder2.AppendLine("# Copyright (c) 2015 Juan Pablo Torrellas. All rights reserved.");
objStreamBuilder2.AppendLine("#");
objStreamBuilder2.AppendLine("##################################################################");
this.text = objStreamBuilder2.ToString();
}
}
return(true);
}
catch
{
return(false);
}
}
public string Encrypt(string text)
{
byte[] input = Encoding.Unicode.GetBytes(text);
byte[] output = Transform(input, _des.CreateEncryptor(_key, _iv));
return(Convert.ToBase64String(output));
}
public bool Register(string user, string pass)
{
byte[] data = UTF8Encoding.UTF8.GetBytes(pass);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
using (TripleDESCryptoServiceProvider tripDes = new TripleDESCryptoServiceProvider()
{
Key = keys, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
})
{
ICryptoTransform transform = tripDes.CreateEncryptor();
byte[] result = transform.TransformFinalBlock(data, 0, data.Length);
pass = Convert.ToBase64String(result, 0, result.Length);
}
}
string query = $"insert into homework.login (username, password) values ('{user}', '{pass}');";
string check = $"select count(*) from homework.login where username='******';";
if (OpenConnection())
{
MySqlCommand cmdcheck = new MySqlCommand(check, conn);
int getValue = Convert.ToInt32(cmdcheck.ExecuteScalar());
if (getValue > 0)
{
MessageBox.Show("The username is already taken!", "Taken", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
conn.Close();
return(false);
}
else
{
try
{
MySqlCommand cmd = new MySqlCommand(query, conn);
try
{
cmd.ExecuteNonQuery();
conn.Close();
return(true);
}
catch (Exception ex)
{
conn.Close();
return(false);
}
}
catch (Exception ex)
{
conn.Close();
return(false);
}
}
}
else
{
conn.Close();
return(false);
}
}
/// <summary>
/// TripleDes Data Encrypt With Ot Encrypt Key Operator
/// </summary>
/// <param name="sourceContent">Source Need to TripleDes Encrpt Data</param>
/// <returns>Encrypt Data Byte[] String</returns>
public static byte[] TripleDesEncryptWithOutKey(string sourceContent)
{
if (string.IsNullOrEmpty(sourceContent))
return null;
var toEncryptSourceStr = Encoding.UTF8.GetBytes(sourceContent);
TripleDESCryptoServiceProvider tripleDesEncryptProvider = new TripleDESCryptoServiceProvider();
ICryptoTransform encryptTransform=tripleDesEncryptProvider.CreateEncryptor();
byte[] encryptToBytes = encryptTransform.TransformFinalBlock(toEncryptSourceStr, 0, toEncryptSourceStr.Length);
return encryptToBytes;
}
/*Sub Header***********************************************************
Function Name: Encrypt
Functionality: This function will upload files to location specified by concating id with the file.
Input: FileUpload,string,int
Output: int
Use format: href='<%# Eval("WebPage") + "?ServiceTypeID=" + HttpUtility.UrlEncode(BLL.CommonFunctions.Encrypt(Eval("ServiceTypeID").ToString()))
Note: Any Special comment
*********************************************************************/
public static string Encrypt(string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
string key = ")(*&";
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data of the Cryptographic service provide. Best Practice
hashmd5.Clear();
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes. We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//Return the encrypted data into unreadable string format
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
public void tweet_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
{
if (e.Key == Key.Escape)
{
tl.Content = "終了処理中...";
string str = Convert.ToString(twpoint);
byte[] srcByteArray;
TripleDESCryptoServiceProvider tdes; // Triple DESサービスプロバイダ
MemoryStream outStream = null;
CryptoStream encStream = null;
string dst = string.Empty;
tl.Content = "暗号化中...";
// Triple DESサービスプロバイダを作成
tdes = new TripleDESCryptoServiceProvider();
// キーと初期化ベクタを取得
byte[] key = Encoding.Unicode.GetBytes(CKEY);
byte[] IV = Encoding.Unicode.GetBytes(CVEC);
// バイト配列を取得
srcByteArray = Encoding.Unicode.GetBytes(str);
// 出力用ストリーム/暗号化ストリームを作成
using (outStream = new MemoryStream())
using (encStream = new CryptoStream(outStream, tdes.CreateEncryptor(key, IV), CryptoStreamMode.Write))
{
// 暗号化
encStream.Write(srcByteArray, 0, srcByteArray.Length);
encStream.Close();
// 暗号化されたデータを文字列にする
dst = Encoding.Unicode.GetString(outStream.ToArray());
string save = Encoding.Unicode.GetString(outStream.ToArray());
tl.Content = "保存中...";
Properties.Settings.Default.point = save;
Properties.Settings.Default.Save();
Environment.Exit(0);
}
}
try
{
if (e.Key == Key.RightCtrl)
{
token.Statuses.Update(status => tweet.Text);
tweet.Text = null;
twpoint += 15;
}
else if (e.Key == Key.LeftCtrl)
{
POST:
string startFolder = Properties.Settings.Default.tvtestpass;
try
{
System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(startFolder);
IEnumerable <System.IO.FileInfo> fileList = dir.GetFiles("*.*", System.IO.SearchOption.TopDirectoryOnly);
string ex = null;
ex = Properties.Settings.Default.img;
IEnumerable <System.IO.FileInfo> fileQuery =
from file in fileList
where file.Extension == ex
orderby file.Name
select file;
try
{
var newestFile =
(from file in fileQuery
orderby file.CreationTime
select new { file.FullName, file.CreationTime })
.Last();
try
{
string photo = newestFile.FullName; // ツイートする画像のパス
string kbtit = null;
if (Properties.Settings.Default.kbtit == true)
{
}
else
{
kbtit = Environment.NewLine + "#Captter http://captter.org";
}
token.Statuses.UpdateWithMedia(
status => tweet.Text + Environment.NewLine + has.Text + kbtit,
media => new FileInfo(photo));
if (Properties.Settings.Default.yaju == true)
{
// イメージブラシの作成
ImageBrush imageBrush = new ImageBrush();
imageBrush.ImageSource = new System.Windows.Media.Imaging.BitmapImage(new Uri(photo, UriKind.Relative));
// ブラシを背景に設定する
this.Background = imageBrush;
}
tweet.Text = null;
twpoint += 25;
}
catch (IOException)
{
System.Windows.Forms.MessageBox.Show("エラーが発生しました。ファイルが使用されています。再試行しますか？", "ふぇぇ");
}
}
catch (System.ArgumentException)
{
System.Windows.MessageBox.Show("初期設定を済ませてください");
}
}
catch (InvalidOperationException) {
System.Windows.MessageBox.Show("フォルダに画像がありません", "ふぇぇ");
}
}
}
catch (TwitterException)
{
System.Windows.MessageBox.Show("Twitter側からエラーを返されました", "ふぇぇ");
}
}
/// <summary>
/// 3des加密字符串
/// </summary>
/// <param name="a_strString">要加密的字符串</param>
/// <param name="a_strKey">密钥</param>
/// <param name="encoding">编码方式</param>
/// <returns>加密后并经base63编码的字符串</returns>
/// <remarks>重载，指定编码方式</remarks>
public string Encrypt3DES(string a_strString, string a_strKey, Encoding encoding)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();
DES.Key = hashMD5.ComputeHash(encoding.GetBytes(a_strKey));
DES.Mode = CipherMode.ECB;
ICryptoTransform DESEncrypt = DES.CreateEncryptor();
byte[] Buffer = encoding.GetBytes(a_strString);
return Convert.ToBase64String(DESEncrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
/// <summary>
/// Gets the crypto service provider.
/// </summary>
/// <param name="bytesKey">The bytes key.</param>
/// <returns></returns>
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
switch (algorithmID)
{
case EncryptionAlgorithm.Des:
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = des.Key;
}
else
{
des.Key = bytesKey;
encKey = des.Key;
}
if (null == initVec)
{
initVec = des.IV;
}
else
{
des.IV = initVec;
}
return(des.CreateEncryptor());
case EncryptionAlgorithm.TripleDes:
TripleDES des3 = new TripleDESCryptoServiceProvider();
des3.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = des3.Key;
}
else
{
des3.Key = bytesKey;
encKey = des3.Key;
}
if (null == initVec)
{
initVec = des3.IV;
}
else
{
des3.IV = initVec;
}
return(des3.CreateEncryptor());
case EncryptionAlgorithm.Rc2:
RC2 rc2 = new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = rc2.Key;
}
else
{
rc2.Key = bytesKey;
encKey = rc2.Key;
}
if (null == initVec)
{
initVec = rc2.IV;
}
else
{
rc2.IV = initVec;
}
return(rc2.CreateEncryptor());
case EncryptionAlgorithm.Rijndael:
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
if (null == bytesKey)
{
encKey = rijndael.Key;
}
else
{
rijndael.Key = bytesKey;
encKey = rijndael.Key;
}
if (null == initVec)
{
initVec = rijndael.IV;
}
else
{
rijndael.IV = initVec;
}
return(rijndael.CreateEncryptor());
default:
throw new CryptographicException("Algorithm ID '" + algorithmID + "' not supported!");
}
}
public String encrypt(String strText)
{
ASCIIEncoding textConverter = new ASCIIEncoding();
byte[] encrypted;
byte[] toEncrypt;
//Encrypt the data.
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
MemoryStream msEncrypt = new MemoryStream();
//Get an encryptor.
ICryptoTransform encryptor = tdes.CreateEncryptor(encKey, initVec);
CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
//Convert the data to a byte array.
toEncrypt = textConverter.GetBytes(strText);
//Write all data to the crypto stream and flush it.
csEncrypt.Write(toEncrypt, 0, toEncrypt.Length);
csEncrypt.FlushFinalBlock();
//Get encrypted array of bytes.
encrypted = msEncrypt.ToArray();
return (HexEncoding.ToString(encrypted));
}
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
DES des;
switch (this.algorithmID)
{
case EncryptionAlgorithm.Des:
des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
if (bytesKey != null)
{
des.Key = bytesKey;
this.encKey = des.Key;
break;
}
this.encKey = des.Key;
break;
case EncryptionAlgorithm.Rc2:
{
RC2 rc = new RC2CryptoServiceProvider();
rc.Mode = CipherMode.CBC;
if (bytesKey != null)
{
rc.Key = bytesKey;
this.encKey = rc.Key;
}
else
{
this.encKey = rc.Key;
}
if (this.initVec == null)
{
this.initVec = rc.IV;
}
else
{
rc.IV = this.initVec;
}
return(rc.CreateEncryptor());
}
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
if (bytesKey != null)
{
rijndael.Key = bytesKey;
this.encKey = rijndael.Key;
}
else
{
this.encKey = rijndael.Key;
}
if (this.initVec == null)
{
this.initVec = rijndael.IV;
}
else
{
rijndael.IV = this.initVec;
}
return(rijndael.CreateEncryptor());
}
case EncryptionAlgorithm.TripleDes:
{
TripleDES edes = new TripleDESCryptoServiceProvider();
edes.Mode = CipherMode.CBC;
if (bytesKey != null)
{
edes.Key = bytesKey;
this.encKey = edes.Key;
}
else
{
this.encKey = edes.Key;
}
if (this.initVec == null)
{
this.initVec = edes.IV;
}
else
{
edes.IV = this.initVec;
}
return(edes.CreateEncryptor());
}
default:
throw new CryptographicException("算法 ID '" + this.algorithmID + "' 不受支持。");
}
if (this.initVec == null)
{
this.initVec = des.IV;
}
else
{
des.IV = this.initVec;
}
return(des.CreateEncryptor());
}
/////////////////////////////////////////////////////////////
#region Debug Operations
#if DEBUG
#if !SILVERLIGHT
private static void MicrosoftDESEncrypt(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt, bool bDESMode)
{
// Declaration of key and IV
byte[] bufferTemp = new byte[1024];
byte[] IV;
if(bDESMode)
IV = new byte[8];
else
IV = new byte[8*3];
// Declare a crypto object
ICryptoTransform crypto;
if (bDESMode)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.PKCS7;
if (bEncrypt)
crypto = des.CreateEncryptor(Key, IV);
else
crypto = des.CreateDecryptor(Key, IV);
}
else
{
TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider();
tripleDes.Padding = PaddingMode.PKCS7;
if (bEncrypt)
crypto = tripleDes.CreateEncryptor(Key, IV);
else
crypto = tripleDes.CreateDecryptor(Key, IV);
}
// a memory stream for the cyrpto
using(MemoryStream ms = new MemoryStream())
{
// Create a CryptoStream using the memory stream
using (CryptoStream encStream = new CryptoStream(ms, crypto, CryptoStreamMode.Write))
{
// Encrypt/decrypt and flush
encStream.Write(bufferIn, 0, bufferIn.Length);
encStream.Flush();
encStream.FlushFinalBlock();
encStream.Close();
// Get the data into a buffer
bufferOut = ms.ToArray();
}
}
}
/// <summary>
/// TripleDES����
/// </summary>
public static string TripleDESEncrypting(string strSource)
{
try
{
byte[] bytIn = Encoding.Default.GetBytes(strSource);
byte[] key = { 42, 16, 93, 156, 78, 4, 218, 32, 15, 167, 44, 80, 26, 20, 155, 112, 2, 94, 11, 204, 119, 35, 184, 197 }; //������Կ
byte[] IV = { 55, 103, 246, 79, 36, 99, 167, 3 }; //����ƫ����
TripleDESCryptoServiceProvider TripleDES = new TripleDESCryptoServiceProvider();
TripleDES.IV = IV;
TripleDES.Key = key;
ICryptoTransform encrypto = TripleDES.CreateEncryptor();
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
byte[] bytOut = ms.ToArray();
return System.Convert.ToBase64String(bytOut);
}
catch (Exception ex)
{
throw new Exception("����ʱ����ִ���!������ʾ:\n" + ex.Message);
}
}
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 bool Isvalid(string _username, string _password, string domain, string LdapPath)
{
byte[] results;
string encryptedPassword;
UTF8Encoding utf8 = new UTF8Encoding();
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] deskey = md5.ComputeHash(utf8.GetBytes(_password));
TripleDESCryptoServiceProvider desalg = new TripleDESCryptoServiceProvider();
desalg.Key = deskey;//to pass encode key
desalg.Mode = CipherMode.ECB;
desalg.Padding = PaddingMode.PKCS7;
byte[] encrypt_data = utf8.GetBytes(_password);
try
{
ICryptoTransform encryptor = desalg.CreateEncryptor();
results = encryptor.TransformFinalBlock(encrypt_data, 0, encrypt_data.Length);
encryptedPassword = Convert.ToBase64String(results);
}
finally
{
desalg.Clear();
md5.Clear();
}
string domainAndUsername = domain + @"\" + _username;
DirectoryEntry entry = new DirectoryEntry(LdapPath, domainAndUsername, _password);
try
{
var a = @"select * from USERS_AUTH
where EMPLOYEE_ID ='" + _username + "' and PASSWORD = '******'";
var ds = dal.GetDataSet(a);
if (ds.Tables[0].Rows.Count > 0)
{
var c = @"select * from USERS_AUTH
where EMPLOYEE_ID ='" + _username + "' and PASSWORD = '******'";
var ds1 = dal.GetDataSet(c);
var dt = ds1.Tables[0];
foreach (System.Data.DataRow dr in dt.Rows) {
Username = dr["EMPLOYEE_ID"].ToString();
Password = dr["PASSWORD"].ToString();
FirstName = dr["FIRSTNAME"].ToString();
LastName = dr["LASTNAME"].ToString();
Roleid = Convert.ToInt32(dr["ROLE_ID"]);
IS_AD = dr["IS_AD"].ToString();
}
return true;
}//end if count
else
{
Object obj = entry.NativeObject;
DirectorySearcher search = new DirectorySearcher(entry);
search.Filter = "(SAMAccountName=" + _username + ")";
search.PropertiesToLoad.Add("cn");
search.PropertiesToLoad.Add("SAMAccountName");
search.PropertiesToLoad.Add("displayName");
SearchResult result = search.FindOne();
LdapPath = result.Path;
string _filterAttribute = (String)result.Properties["cn"][0];
string _filterNameAttribute = (String)result.Properties["SAMAccountName"][0];
string _filterFullnameAttribute = (String)result.Properties["displayName"][0];
var u = @"select * from USERS_AUTH where EMPLOYEE_ID ='" + _filterAttribute + "'and IS_AD = '1'";
var ds2 = dal.GetDataSet(u);
if ((result != null && ds2.Tables[0].Rows.Count > 0) || (result == null && ds2.Tables[0].Rows.Count > 0))
{
var e = @"select * from USERS_AUTH where EMPLOYEE_ID ='" + _filterAttribute + "'and IS_AD = '1'";
var ds3 = dal.GetDataSet(e);
var dt = ds3.Tables[0];
foreach (System.Data.DataRow dr in dt.Rows)
{
Username = dr["EMPLOYEE_ID"].ToString();
Password = dr["PASSWORD"].ToString();
Roleid = Convert.ToInt32(dr["ROLE_ID"]);
IS_AD = dr["IS_AD"].ToString();
}
return true;
}
else
{
return false;
}
}
}//try
catch (Exception ex)
{
// throw an error
}
return false;
}
public byte[] Encriptar(byte[] input)
{
return(Transform(input,
m_des.CreateEncryptor(m_key, m_iv)));
}
public static string Encrypt(string toEncrypt, bool useHashing)
{
/*
* Reference to: Syed Moshiur - Software Developer
* http://www.codeproject.com/Articles/14150/Encrypt-and-Decrypt-Data-with-C
*
*/
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
System.Configuration.AppSettingsReader settingsReader =
new AppSettingsReader();
// Get the key from config file
string key = (string)settingsReader.GetValue("SecurityKey",
typeof(String));
//If hashing use get hashcode regards to your key
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resultArray =
cTransform.TransformFinalBlock(toEncryptArray, 0,
toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//Return the encrypted data into unreadable string format
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
/// <summary>
/// 根据提供的枚举信息,获得需要使用的加密算法的接口
/// </summary>
/// <param name="algorithm">算法枚举</param>
/// <returns></returns>
internal ICryptoTransform GetEncryptoServiceProvider(EncryptionAlgorithm algorithm)
{
switch (algorithm)
{
case EncryptionAlgorithm.Des:
{
DES des = new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
if (null != m_Key)
{
des.Key = m_Key;
}
else
{
m_Key = des.Key;
}
if (null != m_initVec)
{
des.IV = m_initVec;
}
else
{
m_initVec = des.IV;
}
return(des.CreateEncryptor());
}
case EncryptionAlgorithm.Rc2:
{
RC2 rc = new RC2CryptoServiceProvider();
rc.Mode = CipherMode.CBC;
if (null != m_Key)
{
rc.Key = m_Key;
}
else
{
m_Key = rc.Key;
}
if (null != m_initVec)
{
rc.IV = m_initVec;
}
else
{
m_initVec = rc.IV;
}
return(rc.CreateEncryptor());
}
case EncryptionAlgorithm.Rijndael:
{
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
if (null != m_Key)
{
rijndael.Key = m_Key;
}
else
{
m_Key = rijndael.Key;
}
if (null != m_initVec)
{
rijndael.IV = m_initVec;
}
else
{
m_initVec = rijndael.IV;
}
return(rijndael.CreateEncryptor());
}
case EncryptionAlgorithm.TripleDes:
{
TripleDES edes = new TripleDESCryptoServiceProvider();
edes.Mode = CipherMode.CBC;
if (null != m_Key)
{
edes.Key = m_Key;
}
else
{
m_Key = edes.Key;
}
if (null != m_initVec)
{
edes.IV = m_initVec;
}
else
{
m_initVec = edes.IV;
}
return(edes.CreateEncryptor());
}
default:
throw new CryptographicException("Algorithm ID '" + algorithm + "' not supported.");
}
}
/// <summary>
/// Encrypt an array of byte
/// </summary>
/// <returns>Returns an encrypted array of bytes</returns>
public byte[] Encrypt(byte[] input)
{
return(Transform(input, _des.CreateEncryptor(_key, _iv)));
}
private static string Encrypt(string strText)
{
string key = "&%#@?,:*";
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.IV = new byte[8];
PasswordDeriveBytes pdb = new PasswordDeriveBytes(key, new byte[-1 + 1]);
des.Key = pdb.CryptDeriveKey("RC2", "MD5", 128, new byte[8]);
MemoryStream ms = new MemoryStream((strText.Length * 2) - 1);
CryptoStream encStream = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
byte[] plainBytes = Encoding.UTF8.GetBytes(strText);
encStream.Write(plainBytes, 0, plainBytes.Length);
encStream.FlushFinalBlock();
byte[] encryptedBytes = new byte[(int)ms.Length - 1 + 1];
ms.Position = 0;
ms.Read(encryptedBytes, 0, (int)ms.Length);
encStream.Close();
return Convert.ToBase64String(encryptedBytes);
}
public bool EncryptAndSaveData()
{
try
{
if (string.IsNullOrEmpty(_configFile))
{
return(false);
}
string plaintext = GetConfigDataString();
if (string.IsNullOrEmpty(plaintext))
{
return(false);
}
// Convert the plaintext string to a byte array.
byte[] plaintextBytes = Encoding.Unicode.GetBytes(plaintext);
// Create the stream.
MemoryStream ms = new MemoryStream();
// Create the encoder to write to the stream.
CryptoStream encStream = new CryptoStream(ms, decProvider.CreateEncryptor(), CryptoStreamMode.Write);
// Use the crypto stream to write the byte array to the stream.
encStream.Write(plaintextBytes, 0, plaintextBytes.Length);
encStream.FlushFinalBlock();
// Convert the encrypted stream to a printable string.
string encryptedData = Convert.ToBase64String(ms.ToArray());
File.WriteAllText(_configFile, encryptedData);
}
catch (CryptographicException crEx)
{
string strMessage = "The config data could not be encrypted before writting to AppConfig.dat." +
crEx.Message;
MessageBox.Show(strMessage);
return(false);
}
catch (FileNotFoundException /*fnfEx*/)
{
string strMessage = _configFile + " could not be found.\n" +
"Download the file from \"Copy Files Screen\" and try again.";;
MessageBox.Show(strMessage);
return(false);
}
catch (IOException ioEx)
{
MessageBox.Show("There is some problem writting the content in AppConfig.dat file.\n" + ioEx.Message);
return(false);
}
catch (UnauthorizedAccessException uaeEx)
{
string strMessage = "You do not have access to write in AppConfig.dat file.\n" + uaeEx.Message;
MessageBox.Show(strMessage);
return(false);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return(false);
}
return(true);
}
static void Main(string[] args)
{
bool chave = false;
bool gatilho = false;
string caminho = "";
string resp = "";
while (resp != "N")
{
int opc;
if (gatilho == false)
{
if (File.Exists("caminho.txt"))
{
StreamReader open2 = new StreamReader("caminho.txt");
caminho = open2.ReadLine();
open2.Close();
}
else
{
caminho = (@"C:\Users\" + Environment.UserName.ToString() + @"\Desktop\usuario.txt");
}
}
Console.Clear();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Caminho atual: " + caminho);
Console.WriteLine("------ Salvar Dados -------");
Console.WriteLine("------ [1] Abrir Dados ----");
Console.WriteLine("------ [2] Criar Dados ----");
Console.WriteLine("------ [3] Mudar Caminho --");
Console.WriteLine("------ [4] Caminho Padrão -");
Console.WriteLine("---------------------------");
Console.Write("Informe o que deseja fazer:");
opc = Convert.ToInt32(Console.ReadLine());
switch (opc)
{
case 1:
try
{
int numeroLinhas = System.IO.File.ReadAllLines(caminho).Length;
if (numeroLinhas > 4)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERRO: Verifique seu arquivo de texto.");
Console.WriteLine("ERRO: Existe linhas a mais no arquivo.");
}
else
{
StreamReader open = new StreamReader(caminho);
string[] txt = open.ReadToEnd().Split('\n');
Console.Write("Informe sua senha para descriptografar:");
string pass2 = Console.ReadLine();
string email2 = txt[0];
string senha2 = txt[1];
string rg2 = txt[2];
string telefone2 = txt[3];
open.Close();
email2 = decript(pass2, email2);
senha2 = decript(pass2, senha2);
rg2 = decript(pass2, rg2);
telefone2 = decript(pass2, telefone2);
if (chave == false)
{
Console.WriteLine("Senha de Criptografia:" + pass2);
Console.WriteLine("Email: > " + email2);
Console.WriteLine("Senha: > " + senha2);
Console.WriteLine("RG: > " + rg2);
Console.WriteLine("Telefone: > " + telefone2);
}
}
}
catch (System.IO.FileNotFoundException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Não existe um arquivo de texto nesse caminho!");
}
break;
case 2:
Console.Write("Primeiro informe sua senha de criptografia [AES]:");
string pass = Console.ReadLine();
Console.Write("Digite seu e-mail:");
string email = Console.ReadLine();
email = cript(pass, email);
Console.Write("Digite sua senha:");
string senha = Console.ReadLine();
senha = cript(pass, senha);
Console.Write("Digite seu RG:");
string rg = Console.ReadLine();
rg = cript(pass, rg);
Console.Write("Digite seu telefone:");
string telefone = Console.ReadLine();
telefone = cript(pass, telefone);
if (File.Exists(caminho) == true)
{
File.Delete(caminho);
}
StreamWriter save = new StreamWriter(caminho, true);
save.WriteLine(email);
save.WriteLine(senha);
save.WriteLine(rg);
save.WriteLine(telefone);
save.Close();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Dados Gravados com sucesso!");
Console.WriteLine("Caminho Atual do Arquivo > " + caminho + ".");
break;
case 3:
Console.Write("Digite CORRETAMENTE o novo caminho:");
caminho = Console.ReadLine();
StreamWriter save2 = new StreamWriter("caminho.txt", true);
save2.WriteLine(caminho);
save2.Close();
gatilho = false;
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Seu caminho foi atualizado para " + caminho);
break;
case 4:
caminho = (@"C:\Users\" + Environment.UserName.ToString() + @"\Desktop\usuario.txt");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Seu caminho foi atualizado para " + caminho);
gatilho = true;
break;
default:
Console.WriteLine("Opção Inválida!");
break;
}
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("Deseja usar novamente? [S][N]");
resp = Console.ReadLine();
if ((resp != "S") && (resp != "N"))
{
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Opção Inválida, lidaremos como se fosse um SIM XD");
}
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Obrigado pela atenção.");
Console.ReadKey();
string cript(string pass, string conteudo)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(pass));
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
byte[] DataToEncrypt = UTF8.GetBytes(conteudo);
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
conteudo = Convert.ToBase64String(Results);
return(conteudo);
}
catch (CryptographicException)
{
Console.WriteLine("Senha de criptografia inválida!");
return(null);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
}
Byte[] DataToDecrypt;
string decript(string pass, string conteudo)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(pass));
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
try
{
DataToDecrypt = Convert.FromBase64String(conteudo);
}
catch (FormatException)
{
Console.WriteLine("Formato de texto inválido para desembaralhar! Tente novamente!");
chave = true;
return(null);
}
try
{
ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
conteudo = UTF8.GetString(Results);
chave = false;
return(conteudo);
}
catch (CryptographicException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERRO: Senha de criptografia incorreta!");
chave = true;
return(null);
}
catch (NullReferenceException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("ERRO: Informe sua senha!");
chave = true;
return(null);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
}
Console.ReadKey();
}
public void testTimer_Tick(object sender, EventArgs e)
{
if (Properties.Settings.Default.point == "")
{
twpoint = Convert.ToDecimal(1);
}
if (twpoint != h)
{
string str = Convert.ToString(twpoint);
byte[] srcByteArray;
TripleDESCryptoServiceProvider tdes; // Triple DESサービスプロバイダ
MemoryStream outStream = null;
CryptoStream encStream = null;
string dst = string.Empty;
tl.Content = "暗号化中...";
// Triple DESサービスプロバイダを作成
tdes = new TripleDESCryptoServiceProvider();
// キーと初期化ベクタを取得
byte[] key = Encoding.Unicode.GetBytes(CKEY);
byte[] IV = Encoding.Unicode.GetBytes(CVEC);
// バイト配列を取得
srcByteArray = Encoding.Unicode.GetBytes(str);
// 出力用ストリーム/暗号化ストリームを作成
using (outStream = new MemoryStream())
using (encStream = new CryptoStream(outStream, tdes.CreateEncryptor(key, IV), CryptoStreamMode.Write))
{
// 暗号化
encStream.Write(srcByteArray, 0, srcByteArray.Length);
encStream.Close();
// 暗号化されたデータを文字列にする
dst = Encoding.Unicode.GetString(outStream.ToArray());
string save = Encoding.Unicode.GetString(outStream.ToArray());
tl.Content = "保存中...";
Properties.Settings.Default.point = save;
Properties.Settings.Default.Save();
}
}
double x;
x = Math.Log(Convert.ToDouble(twpoint), Convert.ToDouble(3));
double y = Math.Floor(x);
if (y >= Convert.ToDouble(3))
{
yukarin.IsEnabled = true;
yukarin.Content = "OXYGEN";
}
else
{
yukarin.IsChecked = false;
yukarin.IsEnabled = false;
yukarin.Content = "レベル不足";
}
int g = Convert.ToInt32(y) + 1;
decimal pta = Convert.ToDecimal(Math.Floor(Math.Pow(g, 3)));
//System.Windows.MessageBox.Show(Convert.ToString(pta));
tl.Content = "LEVEL:" + Convert.ToString(y) + " " + Convert.ToString(twpoint) + "pt" /*+"次のレベルまで(バグあり)" + Convert.ToString(pta - Convert.ToDecimal(twpoint)) + "pt"*/;
if (Properties.Settings.Default.aniki == true)
{
Properties.Settings.Default.aniki = false;
Properties.Settings.Default.Save();
Properties.Settings.Default.Reload();
System.Windows.Forms.Application.Restart();
Environment.Exit(0);
}
else if (Properties.Settings.Default.oxygen == true)
{
string startFolder = Properties.Settings.Default.tvtestpass;
try
{
System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(startFolder);
IEnumerable <System.IO.FileInfo> fileList = dir.GetFiles("*.*", System.IO.SearchOption.TopDirectoryOnly);
string ex = null;
ex = Properties.Settings.Default.img;
IEnumerable <System.IO.FileInfo> fileQuery =
from file in fileList
where file.Extension == ex
orderby file.Name
select file;
var newestFile =
(from file in fileQuery
orderby file.CreationTime
select new { file.FullName, file.CreationTime })
.Last();
string photo = newestFile.FullName; // ツイートする画像のパス
if (Properties.Settings.Default.imgpass == photo)
{
return;
}
else if (photo != h**o)
{
string kbtit = null;
if (Properties.Settings.Default.kbtit == true)
{
}
else
{
kbtit = Environment.NewLine + "#Captter http://captter.org";
}
token.Statuses.UpdateWithMedia(
status => tweet.Text + Environment.NewLine + has.Text + kbtit,
media => new FileInfo(photo));
if (Properties.Settings.Default.yaju == true)
{
// イメージブラシの作成
ImageBrush imageBrush = new ImageBrush();
imageBrush.ImageSource = new System.Windows.Media.Imaging.BitmapImage(new Uri(photo, UriKind.Relative));
// ブラシを背景に設定する
this.Background = imageBrush;
}
h**o = photo;
Properties.Settings.Default.imgpass = photo;
tweet.Text = null;
twpoint += 5;
}
}
catch (Exception)
{
}
}
h = twpoint;
}
public static string Encrypt(string symmetricKey, string message, out string IV)
{
using (TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider())
{
//Converts to 24 Bytes
byte[] symKey = Convert.FromBase64String(symmetricKey);
Array.Resize(ref symKey, 24);
//Accepts 16, 24 byte Keysizes
des.Key = symKey;
IV = Convert.ToBase64String(des.IV);
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, des.CreateEncryptor(), CryptoStreamMode.Write))
{
byte[] plainText = encoding.GetBytes(message);
cryptoStream.Write(plainText, 0, plainText.Length);
}
message = Convert.ToBase64String(memoryStream.ToArray());
}
}
return(message);
}
/// <summary>
/// Triple DES encryption
/// </summary>
/// <param name="val">Accepts value to be encrypted using Triple DES</param>
/// <returns>Returns value encrypted in Triple DES</returns>
public static string EncryptTripleDES(string val)
{
string encrypted = "";
if (val != "") {
TripleDESCryptoServiceProvider cryptoProvider = new TripleDESCryptoServiceProvider();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, cryptoProvider.CreateEncryptor(KEY_192, IV_192), CryptoStreamMode.Write);
StreamWriter sw = new StreamWriter(cs);
sw.Write(val);
sw.Flush();
cs.FlushFinalBlock();
ms.Flush();
//convert back to string
encrypted = Convert.ToBase64String(ms.GetBuffer(), 0, Convert.ToInt32(ms.Length));
}
return encrypted;
}
