/// <summary>将某种格式的密文转为加密后的二进制数据</summary>
/// <param name="ciphertext">密文</param>
/// <param name="format">密文格式</param>
/// <returns>加密后的二进制数据</returns>
public static byte[] FromCiphertext(string ciphertext, CiphertextFormat format)
{
byte[] result = null;
if (format == CiphertextFormat.Base64String)
{
result = Convert.FromBase64String(ciphertext);
}
else if (format == CiphertextFormat.HexString)
{
string[] data = ciphertext.Split('-');
result = new byte[data.Length];
Int32Converter converter = new Int32Converter();
for (int i = 0; i < data.Length; i++)
{
result[i] = Convert.ToByte(converter.ConvertFromInvariantString(string.Format("0x{0}", data[i])).ToString());
}
}
else if (format == CiphertextFormat.HexStringWhitoutHyphen)
{
result = new byte[ciphertext.Length / 2];
Int32Converter converter = new Int32Converter();
for (int i = 0; i < ciphertext.Length; i = i + 2)
{
result[i / 2] = Convert.ToByte(converter.ConvertFromInvariantString(string.Format("0x{0}", ciphertext.Substring(i, 2)).ToString()));
}
}
return(result);
}
public static string Decrypt(EncryptionAlgorithm algorithm, CiphertextFormat format, string data, Key key,
byte[] salt, byte[] iv, PaddingMode paddingMode)
{
var _d = new byte[0];
switch (format)
{
case CiphertextFormat.Base64:
{
_d = Convert.FromBase64String(data);
break;
}
case CiphertextFormat.Hex:
{
_d = HexToByteArray(data);
break;
}
case CiphertextFormat.Url:
{
var encoding = new UTF8Encoding();
_d = encoding.GetBytes(HttpUtility.UrlDecode(data));
break;
}
}
return(Decrypt(algorithm, _d, key, salt, iv, paddingMode));
}
public static string Decrypt(EncryptionAlgorithm algorithm, CiphertextFormat format, string data, Key key,
byte[] salt, byte[] iv, PaddingMode paddingMode)
{
var _d = new byte[0];
switch (format)
{
case CiphertextFormat.Base64:
{
_d = Convert.FromBase64String(data);
break;
}
case CiphertextFormat.Hex:
{
_d = HexToByteArray(data);
break;
}
case CiphertextFormat.Url:
{
var encoding = new UTF8Encoding();
_d = encoding.GetBytes(HttpUtility.UrlDecode(data));
break;
}
}
return Decrypt(algorithm, _d, key, salt, iv, paddingMode);
}
/// <summary>解密-AES方式</summary>
/// <param name="text">文本</param>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>解密后的文本</returns>
public static string DecryptAES(string text, byte[] key, byte[] iv, CiphertextFormat format)
{
var mode = (CipherMode)Enum.Parse(typeof(CipherMode), SecurityConfigurationView.Instance.AESCryptoMode);
var padding = (PaddingMode)Enum.Parse(typeof(PaddingMode), SecurityConfigurationView.Instance.AESCryptoPadding);
return(DecryptAES(text, key, iv, mode, padding, format));
}
/// <summary>加密-SHA1方式</summary>
/// <param name="text">文本</param>
/// <param name="format">密文格式</param>
/// <returns>加密后的文本</returns>
public static string EncryptSHA1(string text, CiphertextFormat format)
{
SHA1 sha1 = new SHA1CryptoServiceProvider();
byte[] result = sha1.ComputeHash(Encoding.UTF8.GetBytes(text));
return(ToCiphertext(result, format));
}
/// <summary>加密-MD5方式</summary>
/// <param name="text">文本</param>
/// <param name="format">密文格式</param>
/// <returns>加密后的文本</returns>
public static string EncryptMD5(string text, CiphertextFormat format)
{
MD5 md5 = new MD5CryptoServiceProvider();
byte[] result = md5.ComputeHash(Encoding.UTF8.GetBytes(text));
return(ToCiphertext(result, format));
}
/// <summary>解密-DES方式</summary>
/// <param name="text">文本</param>
/// <param name="rgbKey">Key</param>
/// <param name="rgbIV">初始化向量</param>
/// <returns></returns>
public static string DecryptDES(string text, byte[] rgbKey, byte[] rgbIV, CiphertextFormat format)
{
byte[] result = null;
byte[] buffer = FromCiphertext(text, format);
DESCryptoServiceProvider desCryptoProvider = new DESCryptoServiceProvider();
using (ICryptoTransform decryptor = desCryptoProvider.CreateDecryptor(rgbKey, rgbIV))
{
result = decryptor.TransformFinalBlock(buffer, 0, buffer.Length);
}
return(UTF8Encoding.UTF8.GetString(result));
}
/// <summary>加密-DES方式</summary>
/// <param name="text">文本</param>
/// <param name="rgbKey">加密的Key</param>
/// <param name="rgbIV">初始化向量</param>
/// <returns>加密后的文本</returns>
public static string EncryptDES(string text, byte[] rgbKey, byte[] rgbIV, CiphertextFormat format)
{
byte[] result = null;
byte[] buffer = UTF8Encoding.UTF8.GetBytes(text);
DESCryptoServiceProvider desCryptoProvider = new DESCryptoServiceProvider();
using (ICryptoTransform encryptor = desCryptoProvider.CreateEncryptor(rgbKey, rgbIV))
{
result = encryptor.TransformFinalBlock(buffer, 0, buffer.Length);
encryptor.Dispose();
}
return(ToCiphertext(result, format));
}
/// <summary>将加密后的二进制数据转为某种格式的文本信息</summary>
/// <param name="result">加密后的二进制结果数据</param>
/// <param name="format">密文格式</param>
/// <returns>格式化后的的加密文本</returns>
public static string ToCiphertext(byte[] result, CiphertextFormat format)
{
switch (format)
{
case CiphertextFormat.Base64String:
return(Convert.ToBase64String(result, 0, result.Length));
case CiphertextFormat.HexString:
return(BitConverter.ToString(result).ToLower());
case CiphertextFormat.HexStringWhitoutHyphen:
return(BitConverter.ToString(result).Replace("-", string.Empty).ToLower());
default:
return(string.Empty);
}
}
public Key(string s, CiphertextFormat format)
{
switch (format)
{
case CiphertextFormat.Hex:
{
GenerateFromHex(s);
break;
}
case CiphertextFormat.Base64:
{
GenerateFromBase64(s);
break;
}
}
}
/// <summary>
/// Use AES to encrypt data string. The output string is the encrypted bytes as a base64 string.
/// The same password must be used to decrypt the string.
/// </summary>
/// <param name="data">Clear string to encrypt.</param>
/// <param name="password">Password used to encrypt the string.</param>
/// <param name="format">Output string format.</param>
/// <returns>Encrypted result as Base64 string.</returns>
public static string EncryptData(string data, string password, CiphertextFormat format)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
var encBytes = EncryptData(Encoding.UTF8.GetBytes(data), password, PaddingMode.ISO10126);
if (format == CiphertextFormat.Hex)
{
return(BitConverter.ToString(encBytes).Replace("-", ""));
}
return(format == CiphertextFormat.Base64 ? Convert.ToBase64String(encBytes) : encBytes.ToString());
}
public static string Encrypt(EncryptionAlgorithm algorithm, CiphertextFormat format, string data, Key key,
byte[] salt, byte[] iv, PaddingMode paddingMode)
{
var _data = Encoding.UTF8.GetBytes(data);
switch (format)
{
case CiphertextFormat.Base64:
{
return(Convert.ToBase64String(Encrypt(algorithm, _data, key, salt, iv, paddingMode)));
}
case CiphertextFormat.Hex:
{
return(BitConverter.ToString(Encrypt(algorithm, _data, key, salt, iv, paddingMode)).Replace("-", ""));
}
case CiphertextFormat.Url:
{
return(HttpUtility.UrlEncode(Encrypt(algorithm, _data, key, salt, iv, paddingMode)));
}
}
return(string.Empty);
}
/// <summary>
/// Decrypt the data string to the original string. The data must be the base64 string
/// returned from the EncryptData method.
/// </summary>
/// <param name="data">Encrypted data generated from EncryptData method.</param>
/// <param name="password">Password used to decrypt the string.</param>
/// <returns>Decrypted string.</returns>
public static string DecryptData(string data, string password, CiphertextFormat format)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
var encBytes = new byte[0];
if (format == CiphertextFormat.Base64)
{
encBytes = Convert.FromBase64String(data);
}
if (format == CiphertextFormat.Hex)
{
encBytes = HexToByteArray(data);
}
var decBytes = DecryptData(encBytes, password, PaddingMode.ISO10126);
return(Encoding.UTF8.GetString(decBytes));
}
public Key(string s, CiphertextFormat format)
{
switch (format)
{
case CiphertextFormat.Hex:
{
GenerateFromHex(s);
break;
}
case CiphertextFormat.Base64:
{
GenerateFromBase64(s);
break;
}
}
}
/// <summary>
/// Use AES to encrypt data string. The output string is the encrypted bytes as a base64 string.
/// The same password must be used to decrypt the string.
/// </summary>
/// <param name="data">Clear string to encrypt.</param>
/// <param name="password">Password used to encrypt the string.</param>
/// <param name="format">Output string format.</param>
/// <returns>Encrypted result as Base64 string.</returns>
public static string EncryptData(string data, string password, CiphertextFormat format)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
var encBytes = EncryptData(Encoding.UTF8.GetBytes(data), password, PaddingMode.ISO10126);
if (format == CiphertextFormat.Hex)
{
return BitConverter.ToString(encBytes).Replace("-", "");
}
return format == CiphertextFormat.Base64 ? Convert.ToBase64String(encBytes) : encBytes.ToString();
}
/// <summary>加密-AES方式</summary>
/// <param name="text">文本</param>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <param name="format">密文格式</param>
/// <returns>加密后的文本</returns>
public static string EncryptAES(string text, string key, string iv, CiphertextFormat format)
{
return(EncryptAES(text, UTF8Encoding.UTF8.GetBytes(key), UTF8Encoding.UTF8.GetBytes(iv), format));
}
public static string Encrypt(EncryptionAlgorithm algorithm, CiphertextFormat format, string data, Key key,
byte[] salt, byte[] iv, PaddingMode paddingMode)
{
var _data = Encoding.UTF8.GetBytes(data);
switch (format)
{
case CiphertextFormat.Base64:
{
return Convert.ToBase64String(Encrypt(algorithm, _data, key, salt, iv, paddingMode));
}
case CiphertextFormat.Hex:
{
return BitConverter.ToString(Encrypt(algorithm, _data, key, salt, iv, paddingMode)).Replace("-", "");
}
case CiphertextFormat.Url:
{
return HttpUtility.UrlEncode(Encrypt(algorithm, _data, key, salt, iv, paddingMode));
}
}
return string.Empty;
}
/// <summary>
/// Decrypt the data string to the original string. The data must be the base64 string
/// returned from the EncryptData method.
/// </summary>
/// <param name="data">Encrypted data generated from EncryptData method.</param>
/// <param name="password">Password used to decrypt the string.</param>
/// <returns>Decrypted string.</returns>
public static string DecryptData(string data, string password, CiphertextFormat format)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (password == null)
{
throw new ArgumentNullException("password");
}
var encBytes = new byte[0];
if (format == CiphertextFormat.Base64)
{
encBytes = Convert.FromBase64String(data);
}
if (format == CiphertextFormat.Hex)
{
encBytes = HexToByteArray(data);
}
var decBytes = DecryptData(encBytes, password, PaddingMode.ISO10126);
return Encoding.UTF8.GetString(decBytes);
}
/// <summary>解密-AES方式</summary>
/// <param name="text">文本</param>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>解密后的文本</returns>
public static string DecryptAES(string text, string key, string iv, CipherMode mode, PaddingMode padding, CiphertextFormat format)
{
return(DecryptAES(text, UTF8Encoding.UTF8.GetBytes(key), UTF8Encoding.UTF8.GetBytes(iv), mode, padding, format));
}
/// <summary>解密-AES方式</summary>
/// <param name="text">文本</param>
/// <param name="key">密钥</param>
/// <param name="iv">初始化向量</param>
/// <returns>解密后的文本</returns>
public static string DecryptAES(string text, byte[] key, byte[] iv, CipherMode mode, PaddingMode padding, CiphertextFormat format)
{
byte[] result = null;
byte[] buffer = FromCiphertext(text, format);
RijndaelManaged rijndaelManaged = new RijndaelManaged();
rijndaelManaged.Key = key;
rijndaelManaged.IV = iv;
rijndaelManaged.Mode = mode;
rijndaelManaged.Padding = padding;
using (ICryptoTransform cTransform = rijndaelManaged.CreateDecryptor())
{
result = cTransform.TransformFinalBlock(buffer, 0, buffer.Length);
}
return(UTF8Encoding.UTF8.GetString(result));
}
