public Stream Encode(string key, Stream dataStream)
{
SymmetricAlgorithm provider = null;
ICryptoTransform encryptor = null;
Stream stream = null;
try
{
provider = GetCryptoProvider(null);
encryptor = provider.CreateEncryptor();
stream = new CryptoStream(dataStream, encryptor, CryptoStreamMode.Write);
return stream.WriteSalt(key).DisposeTogetherWith(provider, encryptor);
}
catch
{
try
{
if (provider != null)
provider.Dispose();
}
catch { }
try
{
if (encryptor != null)
encryptor.Dispose();
}
catch { }
try
{
if (stream != null)
stream.Dispose();
}
catch { }
throw;
}
}
///<summary>Encrypts signature text and returns a base 64 string so that it can go directly into the database.</summary>
public static string Encrypt(string str,byte[] key){
//No need to check RemotingRole; no call to db.
if(str==""){
return "";
}
byte[] ecryptBytes=Encoding.UTF8.GetBytes(str);
MemoryStream ms=new MemoryStream();
CryptoStream cs=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform encryptor=aes.CreateEncryptor(aes.Key,aes.IV);
cs=new CryptoStream(ms,encryptor,CryptoStreamMode.Write);
cs.Write(ecryptBytes,0,ecryptBytes.Length);
cs.FlushFinalBlock();
byte[] encryptedBytes=new byte[ms.Length];
ms.Position=0;
ms.Read(encryptedBytes,0,(int)ms.Length);
cs.Dispose();
ms.Dispose();
if(aes!=null) {
aes.Clear();
}
return Convert.ToBase64String(encryptedBytes);
}
public static string DecryptFromByteArray(byte[] data)
{
System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(data);
string @string;
try
{
System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, new System.Security.Cryptography.TripleDESCryptoServiceProvider().CreateDecryptor(StringUtils.Key(), StringUtils.Iv()), System.Security.Cryptography.CryptoStreamMode.Read);
try
{
byte[] array = new byte[data.Length];
int count = cryptoStream.Read(array, 0, array.Length);
@string = new System.Text.UTF8Encoding().GetString(array, 0, count);
}
finally
{
cryptoStream.Dispose();
}
}
finally
{
memoryStream.Dispose();
}
return(@string);
}
public static byte[] EncryptToByteArray(string str)
{
byte[] bytes = new System.Text.UTF8Encoding().GetBytes(str);
System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();
byte[] result;
try
{
System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, new System.Security.Cryptography.TripleDESCryptoServiceProvider().CreateEncryptor(StringUtils.Key(), StringUtils.Iv()), System.Security.Cryptography.CryptoStreamMode.Write);
try
{
cryptoStream.Write(bytes, 0, bytes.Length);
cryptoStream.FlushFinalBlock();
result = memoryStream.ToArray();
}
finally
{
cryptoStream.Dispose();
}
}
finally
{
memoryStream.Dispose();
}
return(result);
}
public string mDecryptURLEncode(string EncryptedText)
{
string DecryptedText = "";
System.Security.Cryptography.ICryptoTransform ssd = rc2.CreateDecryptor();
string sEncrypt = HttpUtility.UrlDecode(EncryptedText);
byte[] cipherBytes = Convert.FromBase64String(sEncrypt);
byte[] initialText = null;
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(cipherBytes))
{
using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, ssd, System.Security.Cryptography.CryptoStreamMode.Read))
{
int iCount = opGetArrLength(cipherBytes);
initialText = new Byte[cipherBytes.Length];
cs.Read(initialText, 0, initialText.Length);
cs.Close();
cs.Dispose();
}
ms.Close();
ms.Dispose();
}
DecryptedText = System.Text.UTF8Encoding.UTF8.GetString(initialText);
return(DecryptedText = DecryptedText.Replace("\0", ""));
}
/// <summary>
/// 解密方法
/// </summary>
/// <param name="Source">待解密的串</param>
/// <returns>经过解密的串</returns>
public string Decrypto(string Source)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
int len;
len = Source.Length / 2;
byte[] inputByteArray = new byte[len];
int x, i;
for (x = 0; x < len; x++)
{
i = Convert.ToInt32(Source.Substring(x * 2, 2), 16);
inputByteArray[x] = (byte)i;
}
try
{
des.Key = ASCIIEncoding.ASCII.GetBytes(Key.Substring(0, 8));
des.IV = ASCIIEncoding.ASCII.GetBytes(IV.Substring(0, 8));
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
string estring = Encoding.Default.GetString(ms.ToArray());
ms.Dispose();
cs.Dispose();
return estring;
}
catch
{
return "";
}
}
public string Decryption() {
try {
byte[] encrypted=Convert.FromBase64String(textInput.Text);
MemoryStream ms=null;
CryptoStream cs=null;
StreamReader sr=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform decryptor=aes.CreateDecryptor(aes.Key,aes.IV);
ms=new MemoryStream(encrypted);
cs=new CryptoStream(ms,decryptor,CryptoStreamMode.Read);
sr=new StreamReader(cs);
string decrypted=sr.ReadToEnd();
ms.Dispose();
cs.Dispose();
sr.Dispose();
if(aes!=null) {
aes.Clear();
}
return decrypted;
}
catch {
MessageBox.Show("Text entered was not valid encrypted text.");
return"";
}
}
public static string decrypt(string input)
{
try
{
string key = Settings.edkey;
RijndaelManaged rj = new RijndaelManaged();
rj.Padding = PaddingMode.Zeros;
rj.Mode = CipherMode.CBC;
rj.KeySize = 256;
rj.BlockSize = 256;
byte[] ky = Encoding.ASCII.GetBytes(key);
byte[] inp = Convert.FromBase64String(input);
byte[] res = new byte[inp.Length];
ICryptoTransform dec = rj.CreateDecryptor(ky, ky);
using (MemoryStream ms = new MemoryStream(inp))
{
using (CryptoStream cs = new CryptoStream(ms, dec, CryptoStreamMode.Read))
{
cs.Read(res, 0, res.Length);
cs.Close();
cs.Dispose();
}
ms.Close();
ms.Dispose();
}
return Encoding.UTF8.GetString(res).Trim().Replace("\0", "");
}
catch (Exception ex) { return ex.Message; }
}
public string Decrypt(string text)
{
byte[] textBytes = StringToBytes(text);
DESCryptoServiceProvider desProvider = new DESCryptoServiceProvider();
MemoryStream writeCryp = new MemoryStream();
CryptoStream crypto = new CryptoStream(writeCryp, desProvider.CreateDecryptor(key, key2), CryptoStreamMode.Write);
crypto.Write(textBytes, 0, textBytes.Length);
crypto.FlushFinalBlock();
byte[] resultBytes = writeCryp.GetBuffer();
int len = Convert.ToInt32(writeCryp.Length);
writeCryp.Close();
crypto.Close();
try
{
crypto.Dispose();
}
catch { }
string result = "";
for (int i = 0; i < len; i++)
result = result.Insert(result.Length, Convert.ToChar(resultBytes[i]).ToString());
return result;
}
/// <summary>
/// Metoda za simetrično kriptiranje
/// </summary>
/// <param name="file"></param>
public void SyncCrypt(string file)
{
string zapis;
zapis = file + ".ecb";
FileStream fstreamU = File.OpenRead(file),
fstreamO = File.OpenWrite(zapis);
long lSize = fstreamU.Length;
byte[] bytes = new byte[BufferSize];
int read = -1;
Rijndael rijndaelAlg = Rijndael.Create();
rijndaelAlg.Mode = CipherMode.ECB;
TextReader streamreader = new StreamReader("tajni_kljuc.txt");
string secretKey = streamreader.ReadLine();
rijndaelAlg.Key = Convert.FromBase64String(secretKey);
streamreader.Close();
CryptoStream cout = new CryptoStream(fstreamO, rijndaelAlg.CreateEncryptor(), CryptoStreamMode.Write);
BinaryWriter bw = new BinaryWriter(cout);
bw.Write(lSize);
while ((read = fstreamU.Read(bytes, 0, bytes.Length)) != 0)
{
cout.Write(bytes, 0, read);
}
cout.Flush();
cout.Close();
cout.Dispose();
fstreamU.Flush();
fstreamU.Close();
fstreamU.Dispose();
}
protected static byte[] ExecuteCryptoServiceProvider(byte[] data, ICryptoTransform cryptoTransform)
{
byte[] inArray;
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream,
cryptoTransform, CryptoStreamMode.Write))
{
try
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
}
catch (Exception ex)
{
throw new CustomException<CryptoServiceExceptionArgs>(
new CryptoServiceExceptionArgs("Error while writing encrypted data to the stream: \n" +
ex.Message));
}
finally
{
cryptoStream.Dispose();
}
}
inArray = memoryStream.ToArray();
}
return inArray;
}
/// <summary>
/// 加密字符串
/// </summary>
/// <param name="encryptString"></param>
/// <returns></returns>
public static string Encrypt(string encryptString)
{
System.IO.MemoryStream mStream = null;
System.Security.Cryptography.CryptoStream cStream = null;
try
{
EncryptUtil des = new EncryptUtil();
byte[] rgbKey = Encoding.UTF8.GetBytes(des.encryptKey.Substring(0, 8));
byte[] rgbIV = Encoding.UTF8.GetBytes(des.encryptIV.Substring(0, 8));
byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
System.Security.Cryptography.DESCryptoServiceProvider dCSP = new System.Security.Cryptography.DESCryptoServiceProvider();
mStream = new System.IO.MemoryStream();
cStream = new System.Security.Cryptography.CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), System.Security.Cryptography.CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return(Convert.ToBase64String(mStream.ToArray()));
}
catch (Exception)
{
return(encryptString);
}
finally
{
if (mStream != null)
{
mStream.Close(); mStream.Dispose();
}
if (cStream != null)
{
cStream.Close(); cStream.Dispose();
}
}
}
public static string encrypt(string input)
{
try
{
string key = Settings.edkey;
RijndaelManaged rj = new RijndaelManaged();
rj.Padding = PaddingMode.Zeros;
rj.Mode = CipherMode.CBC;
rj.KeySize = 256;
rj.BlockSize = 256;
byte[] ky = Encoding.ASCII.GetBytes(key);
byte[] inp = Encoding.ASCII.GetBytes(input);
byte[] res;
ICryptoTransform enc = rj.CreateEncryptor(ky, ky);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, enc, CryptoStreamMode.Write))
{
cs.Write(inp, 0, inp.Length);
cs.FlushFinalBlock();
cs.Close();
cs.Dispose();
}
res = ms.ToArray();
ms.Close();
ms.Dispose();
}
return Convert.ToBase64String(res).Replace("+", "%");
}
catch { return null; }
}
/// <summary>
/// AES 解密(高级加密标准，是下一代的加密算法标准，速度快，安全级别高，目前 AES 标准的一个实现是 Rijndael 算法)
/// </summary>
/// <param name="decryptString">待解密密文</param>
/// <param name="decryptKey">解密密钥</param>
/// <returns></returns>
public static string AESDecrypt(string decryptString, string decryptKey)
{
if (string.IsNullOrEmpty(decryptString)) { throw (new Exception("密文不得为空")); }
if (string.IsNullOrEmpty(decryptKey)) { throw (new Exception("密钥不得为空")); }
string m_strDecrypt = "";
Rijndael m_AESProvider = Rijndael.Create();
try
{
byte[] m_btDecryptString = Convert.FromBase64String(decryptString);
MemoryStream m_stream = new MemoryStream();
CryptoStream m_csstream = new CryptoStream(m_stream, m_AESProvider.CreateDecryptor(Encoding.Default.GetBytes(decryptKey), m_btIV), CryptoStreamMode.Write);
m_csstream.Write(m_btDecryptString, 0, m_btDecryptString.Length); m_csstream.FlushFinalBlock();
m_strDecrypt = Encoding.Default.GetString(m_stream.ToArray());
m_stream.Close(); m_stream.Dispose();
m_csstream.Close(); m_csstream.Dispose();
}
catch (IOException ex) { throw ex; }
catch (CryptographicException ex) { throw ex; }
catch (ArgumentException ex) { throw ex; }
catch (Exception ex) { throw ex; }
finally { m_AESProvider.Clear(); }
return m_strDecrypt;
}
public static string Decrypt(string str,byte[] key)
{
//No need to check RemotingRole; no call to db.
if(str==""){
return "";
}
try {
byte[] encrypted=Convert.FromBase64String(str);
MemoryStream ms=null;
CryptoStream cs=null;
StreamReader sr=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform decryptor=aes.CreateDecryptor(aes.Key,aes.IV);
ms=new MemoryStream(encrypted);
cs=new CryptoStream(ms,decryptor,CryptoStreamMode.Read);
sr=new StreamReader(cs);
string decrypted=sr.ReadToEnd();
ms.Dispose();
cs.Dispose();
sr.Dispose();
if(aes!=null) {
aes.Clear();
}
return decrypted;
}
catch {
//MessageBox.Show("Text entered was not valid encrypted text.");
return"";
}
}
public void EncryptFile(PasswordSheet sheet)
{
FileStream stream = null;
PasswordDeriveBytes secretKey = null;
RijndaelManaged rijndaelCipher = null;
ICryptoTransform encryptor = null;
CryptoStream cryptoStream = null;
try
{
stream = new FileStream(_fileName, FileMode.OpenOrCreate, FileAccess.Write);
stream.SetLength(0);
secretKey = GetPasswordBytes();
rijndaelCipher = new RijndaelManaged();
encryptor = rijndaelCipher.CreateEncryptor(secretKey.GetBytes(32), secretKey.GetBytes(16));
// Defines a stream that links data streams to cryptographic transformations
cryptoStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Write);
byte[] data = null;
using (var sheetStream = new MemoryStream())
{
XmlSerializer serializer = new XmlSerializer(typeof(PasswordSheet));
serializer.Serialize(sheetStream, sheet);
data = sheetStream.GetBuffer();
}
cryptoStream.Write(data, 0, data.Length);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
finally
{
if (secretKey != null)
{
secretKey.Dispose();
}
if (rijndaelCipher != null)
{
rijndaelCipher.Dispose();
}
if (cryptoStream != null)
{
cryptoStream.Dispose();
}
}
}
public PasswordSheet DecryptFile()
{
PasswordSheet decryptedData = null;
FileStream stream = null;
PasswordDeriveBytes secretKey = null;
RijndaelManaged rijndaelCipher = null;
ICryptoTransform decryptor = null;
CryptoStream cryptoStream = null;
try
{
rijndaelCipher = new RijndaelManaged();
// Making of the key for decryption
secretKey = GetPasswordBytes();
// Creates a symmetric Rijndael decryptor object.
decryptor = rijndaelCipher.CreateDecryptor(secretKey.GetBytes(32), secretKey.GetBytes(16));
stream = new FileStream(_fileName, FileMode.Open, FileAccess.Read);
// Defines the cryptographics stream for decryption.THe stream contains decrpted data
cryptoStream = new CryptoStream(stream, decryptor, CryptoStreamMode.Read);
XmlSerializer serializer = new XmlSerializer(typeof(PasswordSheet));
decryptedData = (PasswordSheet)serializer.Deserialize(cryptoStream);
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.Message);
}
finally
{
if (stream != null)
{
stream.Dispose();
}
if (secretKey != null)
{
secretKey.Dispose();
}
if (rijndaelCipher != null)
{
rijndaelCipher.Dispose();
}
if (cryptoStream != null)
{
cryptoStream.Dispose();
}
}
return decryptedData;
}
/// <summary>
/// Decrypts string data. Uses specific password as a key.
/// </summary>
/// <param name="dataToDecrypt">Encrypted data.</param>
/// <param name="password">Password used as a key to decryption.</param>
/// <param name="salt">String used to generate key based on password. Must be at least 8 bytes long.</param>
/// <returns>Decrypted string data.</returns>
public string Decrypt(string dataToDecrypt, string password, string salt)
{
AesManaged aes = null;
MemoryStream memoryStream = null;
try
{
// Generate a Key based on a Password and HMACSHA1 pseudo-random number generator
// Salt must be at least 8 bytes long
// Use an iteration count of at least 1000
Rfc2898DeriveBytes rfc2898 = new Rfc2898DeriveBytes(password, Encoding.UTF8.GetBytes(salt), 10000);
// Create AES algorithm
aes = new AesManaged();
// Key derived from byte array with 32 pseudo-random key bytes
aes.Key = rfc2898.GetBytes(32);
// IV derived from byte array with 16 pseudo-random key bytes
aes.IV = rfc2898.GetBytes(16);
// Create Memory and Crypto Streams
memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Write);
// Decrypt Data
byte[] data = Convert.FromBase64String(dataToDecrypt);
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
// Return Decrypted String
byte[] decryptBytes = memoryStream.ToArray();
// Dispose
if (cryptoStream != null)
{
cryptoStream.Dispose();
}
// Retval
return Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
}
finally
{
if (memoryStream != null)
{
memoryStream.Dispose();
}
if (aes != null)
{
aes.Clear();
}
}
}
private static void Main(string[] args)
{
string action = "DECRYPT", filePath = "";
if (args.Length < 1 || args[0] == "/?")
{
Console.Error.WriteLine("Aes256 Encryption/Decryption.");
Console.Error.WriteLine();
Console.Error.WriteLine("crypt.exe [-e] <filepath>"); // args[0] args[1]
Console.Error.WriteLine(" -e encrypting the file, default is decrypting");
Console.Error.WriteLine(" <filepath> path of file to be encrypted or decrypted");
Console.Error.WriteLine();
return;
}
else if (args.Length > 1 && args[0] == "-e")
{
action = "ENCRYPT";
filePath = args[1];
}
else
{
filePath = args[0];
}
// [ https://www.codeproject.com/Questions/562372/Theplusinputplusdataplusisplusnotplusapluscomplete ]
FileStream reader = new FileStream(filePath, FileMode.Open, FileAccess.Read);
FileStream writer = new FileStream(filePath + ".out", FileMode.OpenOrCreate, FileAccess.Write);
using (var aes = getAes256Provider()) {
using (ICryptoTransform cryptor = (action == "DECRYPT") ? aes.CreateDecryptor(aes.Key, aes.IV) : aes.CreateEncryptor(aes.Key, aes.IV)) {
//Create a Crypt Stream using the encryptor/decryptor created above
System.Security.Cryptography.CryptoStream cryptoStream
= new System.Security.Cryptography.CryptoStream(writer, cryptor, CryptoStreamMode.Write);
byte[] bites = new byte[1024]; //Stores 1 KB
Int32 bitesRead = 0; //Number of Bytes read
Int64 totalBites = 0; //Total Number of Bytes read
//Loop through the entire file reading 1 kb at a time
while (!(totalBites >= reader.Length))
{
bitesRead = reader.Read(bites, 0, 1024); //Read the bytes from the input file.
cryptoStream.Write(bites, 0, bitesRead); //Write the encrypted bytes to the output file.
totalBites += bitesRead;
}
cryptoStream.Close(); cryptoStream.Dispose();
cryptor.Dispose();
}
}
//Close and release streams:
reader.Close(); reader.Dispose();
writer.Close(); writer.Dispose();
}
/// <summary>
/// 解密字符串
/// </summary>
public static string Decrypt(string ciphertext)
{
string password2 = "Ahbool";
string cipher = string.Empty;
try
{
char[] key = new char[8];
if (password.Length > 8)
{
password = password.Remove(8);
}
password.CopyTo(0, key, 0, password.Length);
char[] iv = new char[8];
if (password2.Length > 8)
{
password2 = password2.Remove(8);
}
password2.CopyTo(0, iv, 0, password2.Length);
if (ciphertext == null)
{
return cipher;
}
SymmetricAlgorithm serviceProvider = new DESCryptoServiceProvider();
serviceProvider.Key = Encoding.ASCII.GetBytes(key);
serviceProvider.IV = Encoding.ASCII.GetBytes(iv);
byte[] contentArray = Convert.FromBase64String(ciphertext);
MemoryStream memoryStream = new MemoryStream(contentArray);
CryptoStream cryptoStream = new CryptoStream(memoryStream, serviceProvider.CreateDecryptor(), CryptoStreamMode.Read);
StreamReader streamReader = new StreamReader(cryptoStream);
cipher = streamReader.ReadToEnd();
streamReader.Dispose();
cryptoStream.Dispose();
memoryStream.Dispose();
serviceProvider.Clear();
}
catch
{
cipher = "123";
}
return cipher;
}
public string Decrypt(string value, string key, string iv)
{
string decrptValue = string.Empty;
if (!string.IsNullOrEmpty(value))
{
MemoryStream ms = null;
CryptoStream cs = null;
value = value.Replace(" ", "+");
byte[] inputByteArray = new byte[value.Length];
try
{
if (!string.IsNullOrEmpty(key))
{
_keyByte = Encoding.UTF8.GetBytes
(key.Substring(0, 8));
if (!string.IsNullOrEmpty(iv))
{
_ivByte = Encoding.UTF8.GetBytes
(iv.Substring(0, 8));
}
}
else
{
_keyByte = Encoding.UTF8.GetBytes(_key);
}
using (DESCryptoServiceProvider des =
new DESCryptoServiceProvider())
{
inputByteArray = Convert.FromBase64String(value);
ms = new MemoryStream();
cs = new CryptoStream(ms, des.CreateDecryptor
(_keyByte, _ivByte), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
Encoding encoding = Encoding.UTF8;
decrptValue = encoding.GetString(ms.ToArray());
}
}
catch
{
//TODO: write log
}
finally
{
cs.Dispose();
ms.Dispose();
}
}
return decrptValue;
}
/// <summary>
/// Encrypt data using MapleStory's AES method
/// </summary>
/// <param name="IV"> IV to use for encryption </param>
/// <param name="data"> data to encrypt </param>
/// <param name="length"> length of data </param>
/// <param name="key"> the AES key to use </param>
/// <returns> Crypted data </returns>
public static byte[] AESCrypt(byte[] IV, byte[] data, int length, byte[] key)
{
AesManaged crypto = new AesManaged();
crypto.KeySize = 256; //in bits
crypto.Key = key;
crypto.Mode = CipherMode.ECB; // Should be OFB, but this works too
MemoryStream memStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memStream, crypto.CreateEncryptor(), CryptoStreamMode.Write);
int remaining = length;
int llength = 0x5B0;
int start = 0;
while (remaining > 0)
{
byte[] myIV = MapleCrypto.MultiplyBytes(IV, 4, 4);
if (remaining < llength)
{
llength = remaining;
}
for (int x = start; x < (start + llength); x++)
{
if ((x - start)%myIV.Length == 0)
{
cryptoStream.Write(myIV, 0, myIV.Length);
byte[] newIV = memStream.ToArray();
Array.Copy(newIV, myIV, myIV.Length);
memStream.Position = 0;
}
data[x] ^= myIV[(x - start)%myIV.Length];
}
start += llength;
remaining -= llength;
llength = 0x5B4;
}
try
{
cryptoStream.Dispose();
memStream.Dispose();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
return data;
}
public static String Decrypt(string cypher)
{
byte[] buffer = Convert.FromBase64String(cypher);
MemoryStream ms = null;
ICryptoTransform transform = null;
CryptoStream stream = null;
try
{
ms = new MemoryStream(buffer, 0, buffer.Length);
transform = _des.CreateDecryptor();
stream = new CryptoStream(ms, transform, CryptoStreamMode.Read);
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
{
var decrypted = reader.ReadToEnd();
return decrypted;
}
}
finally
{
if (stream != null)
stream.Dispose();
if (transform != null)
transform.Dispose();
if (ms != null)
ms.Dispose();
}
//Rather using try-finally block to be sure that some of the streams are not disposed several times
//which could happen in the following case:
//using (MemoryStream ms = new MemoryStream(buffer, 0, buffer.Length))
//{
// using (ICryptoTransform transform = _des.CreateDecryptor())
// {
// using (CryptoStream stream = new CryptoStream(ms, transform, CryptoStreamMode.Read))
// {
// using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
// {
// var decrypted = reader.ReadToEnd();
// return decrypted;
// }
// }
// }
//}
}
/// <summary>
/// AES����
/// </summary>
/// <param name="decData">�����ֽ�����</param>
/// <param name="token">��Կ</param>
/// <returns>���ؽ��ܺ���ַ���</returns>
public static byte[] Decrypt(byte[] decData, string token)
{
// if (decData.Length != ivKeys.Length)
//{
// throw new CryptographicException("keys length is not valid!");
//}
SymmetricAlgorithm des = Rijndael.Create();
des.Key = Encoding.UTF8.GetBytes(token);
des.IV = ivKeys;
byte[] decryptBytes = new byte[decData.Length];
MemoryStream ms = new MemoryStream(decData);
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read);
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Dispose();
ms.Dispose();
return decryptBytes;
}
/// <summary>
/// Decrypt a string
/// </summary>
/// <param name="Value"></param>
/// <returns></returns>
public static string Decrypt(string Value)
{
SymmetricAlgorithm mCSP;
ICryptoTransform ct = null;
MemoryStream memoryStream = null;
CryptoStream cryptoStream = null;
byte[] byt;
byte[] _result;
mCSP = new RijndaelManaged();
try
{
mCSP.Key = _key;
mCSP.IV = _initVector;
ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV);
byt = Convert.FromBase64String(Value);
memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, ct, CryptoStreamMode.Write);
cryptoStream.Write(byt, 0, byt.Length);
cryptoStream.FlushFinalBlock();
cryptoStream.Close();
_result = memoryStream.ToArray();
}
catch
{
_result = null;
}
finally
{
if (ct != null)
ct.Dispose();
if (memoryStream != null)
memoryStream.Dispose();
if (cryptoStream != null)
cryptoStream.Dispose();
}
return ASCIIEncoding.UTF8.GetString(_result);
}
private const string _salt = "salt"; // Not for UI. Do not change.
#endregion Fields
#region Methods
public static string Decrypt(string dataToDecrypt, string password = "", string salt = "")
{
AesManaged aes = null;
MemoryStream memoryStream = null;
CryptoStream cryptoStream = null;
try
{
if (password.CompareTo("") == 0) password = _password;
if (salt.CompareTo("") == 0) salt = _salt;
//Generate a Key based on a Password, Salt and HMACSHA1 pseudo-random number generator
Rfc2898DeriveBytes rfc2898 = new Rfc2898DeriveBytes(password, Encoding.UTF8.GetBytes(salt));
//Create AES algorithm with 256 bit key and 128-bit block size
aes = new AesManaged();
aes.Key = rfc2898.GetBytes(aes.KeySize / 8);
aes.IV = rfc2898.GetBytes(aes.BlockSize / 8);
//Create Memory and Crypto Streams
memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Write);
//Decrypt Data
byte[] data = Convert.FromBase64String(dataToDecrypt);
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
//Return Decrypted String
byte[] decryptBytes = memoryStream.ToArray();
return Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
}
finally
{
if (cryptoStream != null)
cryptoStream.Dispose();
if (memoryStream != null)
memoryStream.Dispose();
if (aes != null)
aes.Clear();
}
}
public static string DesDecrypt(string pToDecrypt, string key, string iv)
{
using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
{
byte[] inputByteArray = Convert.FromBase64String(pToDecrypt);/*new byte[pToDecrypt.Length / 2];
for (int x = 0; x < pToDecrypt.Length / 2; x++)
{
int i = Convert.ToInt32(pToDecrypt.Substring(x * 2, 2), 16);
inputByteArray[x] = (byte)i;
}*/
des.Key = ASCIIEncoding.ASCII.GetBytes(key);
des.IV = ASCIIEncoding.ASCII.GetBytes(iv);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
cs.Dispose();
//StringBuilder ret = new StringBuilder();
return Encoding.Default.GetString(ms.ToArray());
}
}
///<summary>Encrypts signature text and returns a base 64 string so that it can go directly into the database.</summary>
public string Encryption(string encrypt){
byte[] ecryptBytes=Encoding.UTF8.GetBytes(encrypt);
MemoryStream ms=new MemoryStream();
CryptoStream cs=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform encryptor=aes.CreateEncryptor(aes.Key,aes.IV);
cs=new CryptoStream(ms,encryptor,CryptoStreamMode.Write);
cs.Write(ecryptBytes,0,ecryptBytes.Length);
cs.FlushFinalBlock();
byte[] encryptedBytes=new byte[ms.Length];
ms.Position=0;
ms.Read(encryptedBytes,0,(int)ms.Length);
cs.Dispose();
ms.Dispose();
if(aes!=null) {
aes.Clear();
}
return Convert.ToBase64String(encryptedBytes);
}
public static System.Version LatestVersion=new Version("15.2.1.0");//This value must be changed when a new conversion is to be triggered.
#region Helper Functions
///<summary>Encrypts signature text and returns a base 64 string so that it can go directly into the database.
///Copied from MiscUtils.Encrypt() so that the data conversion will never change historically.</summary>
public static string Encrypt(string encrypt) {
UTF8Encoding enc=new UTF8Encoding();
byte[] arrayEncryptBytes=Encoding.UTF8.GetBytes(encrypt);
MemoryStream ms=new MemoryStream();
CryptoStream cs=null;
Aes aes=new AesManaged();
aes.Key=enc.GetBytes("AKQjlLUjlcABVbqp");
aes.IV=new byte[16];
ICryptoTransform encryptor=aes.CreateEncryptor(aes.Key,aes.IV);
cs=new CryptoStream(ms,encryptor,CryptoStreamMode.Write);
cs.Write(arrayEncryptBytes,0,arrayEncryptBytes.Length);
cs.FlushFinalBlock();
byte[] retval=new byte[ms.Length];
ms.Position=0;
ms.Read(retval,0,(int)ms.Length);
cs.Dispose();
ms.Dispose();
if(aes!=null) {
aes.Clear();
}
return Convert.ToBase64String(retval);
}
/// <summary>
/// 加密数据
/// </summary>
/// <param name="Text"></param>
/// <param name="sKey"></param>
/// <returns></returns>
public static string Encrypt(string Text, string sKey)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] inputByteArray;
inputByteArray = Encoding.Default.GetBytes(Text);
des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
StringBuilder ret = new StringBuilder();
foreach (byte b in ms.ToArray())
{
ret.AppendFormat("{0:X2}", b);
}
cs.Close();
cs.Dispose();
ms.Close();
ms.Dispose();
return ret.ToString();
}
public static byte[] GenerateWzKey(byte[] WzIv, byte[] AesKey)
{
if (BitConverter.ToInt32(WzIv, 0) == 0)
{
return new byte[ushort.MaxValue];
}
AesManaged crypto = new AesManaged();
crypto.KeySize = 256;
crypto.Key = AesKey;
crypto.Mode = CipherMode.ECB;
MemoryStream memStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memStream, crypto.CreateEncryptor(), CryptoStreamMode.Write);
byte[] input = MapleCrypto.multiplyBytes(WzIv, 4, 4);
byte[] wzKey = new byte[ushort.MaxValue];
for (int i = 0; i < (wzKey.Length / 16); i++)
{
cryptoStream.Write(input, 0, 16);
input = memStream.ToArray();
Array.Copy(input, 0, wzKey, (i * 16), 16);
memStream.Position = 0;
}
cryptoStream.Write(input, 0, 16);
Array.Copy(memStream.ToArray(), 0, wzKey, (wzKey.Length - 15), 15);
try
{
cryptoStream.Dispose();
memStream.Dispose();
}
catch (Exception e)
{
Helpers.ErrorLogger.Log(Helpers.ErrorLevel.Critical, "Error disposing AES streams" + e);
}
return wzKey;
}
private void btn_dencrypt_Click(object sender, EventArgs e)
{
String toDecrypt = tb_toDencryptUTF8.Text;
if (String.IsNullOrEmpty(toDecrypt)) return;
AesCryptoServiceProvider aes = null;
MemoryStream ms = null;
CryptoStream cs = null;
try
{
aes = new AesCryptoServiceProvider();
aes.Key = key;
aes.IV = iv;
var encrypted = Convert.FromBase64String(tb_toDencryptB64.Text);
ms = new MemoryStream(encrypted);
cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read);
byte[] buffer = new byte[encrypted.Length];
int offset = cs.Read(buffer, 0, buffer.Length);
tb_dencrypted.Text = Encoding.UTF8.GetString(buffer, 0, offset);
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
finally
{
if (aes != null) aes.Dispose();
if (cs != null) cs.Dispose();
if (ms != null) ms.Dispose();
}
}
//private String mDBPartition;
public int dbDecrypt(String partition, int size, String data, out String decryptedData)
{
AesManaged aes = null;
MemoryStream memoryStream = null;
try
{
aes = new AesManaged();
aes.Key = readKeyFromFile(partition);
memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Write);
byte[] buf = Convert.FromBase64String(data);
cryptoStream.Write(buf, 0, buf.Length);
cryptoStream.FlushFinalBlock();
byte[] decryptBytes = memoryStream.ToArray();
if (cryptoStream != null)
cryptoStream.Dispose();
decryptedData = Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
}
finally
{
if (memoryStream != null)
memoryStream.Dispose();
if (aes != null)
aes.Clear();
}
return getErrorCode() == 0 ? 1 : 0;
}
void Encrypt(OnCommandArgs args, string[] inMsg)
{
if (inMsg.Length < 3){
_ircInterface.Client.SendMessage(SendType.Message, args.Source, args.Nick + " the syntax for this command is .encrypt <key> <data>");
return;
}
try{
var key = AsciiToBase10(inMsg[1].ToCharArray());
var msg = AssembleMessage(inMsg.Skip(2).ToList());
msg = msg.Remove(msg.Length - 1);
var msgByte = AsciiToBase10(msg.ToCharArray());
if (msgByte.Length%16 != 0){
var paddedLen = (msgByte.Length/16 + 1)*16;
msgByte = PKCS7(msgByte, paddedLen);
}
var aes = new AesManaged();
aes.KeySize = 128;
aes.Mode = CipherMode.CBC;
aes.Key = PKCS7(key, 16);
aes.Padding = PaddingMode.None;
aes.IV = new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
var memStrm = new MemoryStream(msgByte.Length);
var cryptStrm = new CryptoStream(memStrm, aes.CreateEncryptor(), CryptoStreamMode.Write);
cryptStrm.Write(msgByte, 0, msgByte.Length);
var ret = memStrm.ToArray();
aes.Dispose();
cryptStrm.Dispose();
memStrm.Dispose();
var retb10 = new string(Convert.ToBase64String(ret).ToCharArray());
_ircInterface.Client.SendMessage(SendType.Message, args.Source, args.Nick + ": " + retb10);
}
catch{
_ircInterface.Client.SendMessage(SendType.Message, args.Source, args.Nick + ": something went wrong during encryption.");
}
}
void Decrypt(OnCommandArgs args, string[] inMsg)
{
if (inMsg.Length < 3){
_ircInterface.Client.SendMessage(SendType.Message, args.Source, args.Nick + " the syntax for this command is .decrypt <key> <data>");
return;
}
try{
var key = AsciiToBase10(inMsg[1].ToCharArray());
var msgByte = Convert.FromBase64CharArray(inMsg[2].ToCharArray(), 0, inMsg[2].Length);
var aes = new AesManaged();
aes.Mode = CipherMode.CBC;
aes.IV = new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
aes.KeySize = 128;
var keyPad = PKCS7(key, 16);
aes.Key = keyPad;
aes.Padding = PaddingMode.None;
var memStrm = new MemoryStream(msgByte.Length);
var cryptStrm = new CryptoStream(memStrm, aes.CreateDecryptor(), CryptoStreamMode.Write);
cryptStrm.Write(msgByte, 0, msgByte.Length);
var ret = memStrm.ToArray();
aes.Dispose();
cryptStrm.Dispose();
memStrm.Dispose();
ret = StripPKCS7(ret);
var retStr = new string(Base10ToAscii(ret));
_ircInterface.Client.SendMessage(SendType.Message, args.Source, args.Nick + ": " + retStr);
}
catch{
_ircInterface.Client.SendMessage
(SendType.Message, args.Source, args.Nick + ": something went wrong during decryption. did you change the encrypted string?");
}
}
