SecurityHelper
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Web;
namespace ConsoleApplication1
{
public class SecurityHelper
{
static readonly String WhiteList = "";
/// <summary>
/// 判断是否白名单
/// </summary>
/// <returns></returns>
public static Boolean JudgeWhiteList(string str)
{
Boolean Result = false;
var strHost = str;
if (!String.IsNullOrWhiteSpace(WhiteList))
{
if (WhiteList.IndexOf(",") > -1)
{
var IpList = WhiteList.Split(',').ToList();
if (IpList.Contains(strHost))
Result = true;
}
else
{
if (WhiteList.Trim() == strHost.Trim())
Result = true;
}
}
return Result;
}
/// <summary>
/// 基于Sha1的自定义加密字符串方法：输入一个字符串，返回一个由40个字符组成的十六进制的哈希散列（字符串）。
/// </summary>
/// <param name="str">要加密的字符串</param>
/// <returns>加密后的十六进制的哈希散列（字符串）</returns>
public static string LowerSha1(string str)
{
byte[] bytes = Encoding.UTF8.GetBytes(str);
byte[] data = SHA1.Create().ComputeHash(bytes);
StringBuilder builder = new StringBuilder();
foreach (byte t in data)
{
builder.Append(t.ToString("X2"));
}
return builder.ToString().ToLower();
}
/// <summary>
/// 基于Sha1的自定义加密字符串方法：输入一个字符串，返回一个由40个字符组成的十六进制的哈希散列（字符串）。
/// </summary>
/// <param name="str">要加密的字符串</param>
/// <returns>加密后的十六进制的哈希散列（字符串）</returns>
public static string UpperSha1(string str)
{
byte[] bytes = Encoding.UTF8.GetBytes(str);
byte[] data = SHA1.Create().ComputeHash(bytes);
StringBuilder builder = new StringBuilder();
foreach (byte t in data)
{
builder.Append(t.ToString("X2"));
}
return builder.ToString().ToUpper();
}
/// <summary>
/// dd 推送业务 header签名验证！
/// </summary>
/// <param name="value"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string HashHmac(string value, string key)
{
var enc = Encoding.UTF8;
HMACSHA1 hmac = new HMACSHA1(enc.GetBytes(key));
hmac.Initialize();
byte[] buffer = enc.GetBytes(value);
string localhostSign = Convert.ToBase64String((byte[])hmac.ComputeHash(buffer));
return localhostSign;
}
public string EncryptSHA1(string Source_String)
{
byte[] StrRes = Encoding.Default.GetBytes(Source_String);
HashAlgorithm iSHA = new SHA1CryptoServiceProvider();
StrRes = iSHA.ComputeHash(StrRes);
StringBuilder EnText = new StringBuilder();
foreach (byte iByte in StrRes)
{
EnText.AppendFormat("{0:x2}", iByte);
}
return EnText.ToString();
}
/// <summary>
/// sha-2 256加密
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string EncryptSHA256(string str)
{
System.Security.Cryptography.SHA256 s256 = new System.Security.Cryptography.SHA256Managed();
byte[] byte1;
byte1 = s256.ComputeHash(Encoding.Default.GetBytes(str));
s256.Clear();
return Convert.ToBase64String(byte1);
}
/// <summary>
/// sha-2 384加密
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public string EncryptSHA384(string str)
{
System.Security.Cryptography.SHA384 s384 = new System.Security.Cryptography.SHA384Managed();
byte[] byte1;
byte1 = s384.ComputeHash(Encoding.Default.GetBytes(str));
s384.Clear();
return Convert.ToBase64String(byte1);
}
/// <summary>
/// sha-2 512加密
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public string EncryptSHA512(string str)
{
System.Security.Cryptography.SHA512 s512 = new System.Security.Cryptography.SHA512Managed();
byte[] byte1;
byte1 = s512.ComputeHash(Encoding.Default.GetBytes(str));
s512.Clear();
return Convert.ToBase64String(byte1);
}
private byte[] Keys = { 0xEF, 0xAB, 0x56, 0x78, 0x90, 0x34, 0xCD, 0x12 };
/// <summary>
/// DES加密算法
/// </summary>
/// <param name="encryptString"></param>
/// <param name="encryptKey"></param>
/// <returns></returns>
public string EncryptDES(string encryptString, string encryptKey)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));
byte[] rgbIV = Keys;
byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Convert.ToBase64String(mStream.ToArray());
}
catch
{
return encryptString;
}
}
/// <summary>
/// DES解密算法
/// </summary>
/// <param name="decryptString"></param>
/// <param name="decryptKey"></param>
/// <returns></returns>
public string DecryptDES(string decryptString, string decryptKey)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey.Substring(0, 8));
byte[] rgbIV = Keys;
byte[] inputByteArray = Convert.FromBase64String(decryptString);
DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Encoding.UTF8.GetString(mStream.ToArray());
}
catch
{
return decryptString;
}
}
/// <summary>
/// 原生app解密算法
/// </summary>
/// <param name="decryptString"></param>
/// <param name="decryptKey"></param>
/// <param name="decryptIV"></param>
/// <returns></returns>
public string DecryptDES(string decryptString, string decryptKey, string decryptIV)
{
try
{
byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
byte[] rgbIV = Keys;
byte[] inputByteArray = Convert.FromBase64String(decryptString);
DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
MemoryStream mStream = new MemoryStream();
CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, Encoding.UTF8.GetBytes(decryptIV)), CryptoStreamMode.Write);
cStream.Write(inputByteArray, 0, inputByteArray.Length);
cStream.FlushFinalBlock();
return Encoding.UTF8.GetString(mStream.ToArray());
}
catch
{
return decryptString;
}
}
/// <summary>
/// 16位MD5加密方法,以前的DVBBS所使用
/// </summary>
/// <param name="strSource">待加密字串</param>
/// <returns>加密后的字串</returns>
public static string EncryptMD5(string strSource)
{
return EncryptMD5(strSource, 16);
}
/// <summary>
/// MD5加密,和动网上的16/32位MD5加密结果相同
/// </summary>
/// <param name="strSource">待加密字串</param>
/// <param name="length">16或32值之一,其它则采用.net默认MD5加密算法</param>
/// <returns>加密后的字串</returns>
public static string EncryptMD5(string strSource, int length)
{
byte[] bytes = Encoding.ASCII.GetBytes(strSource);
byte[] hashValue =
((HashAlgorithm)
CryptoConfig.CreateFromName("MD5")).ComputeHash(bytes);
var sb = new StringBuilder();
switch (length)
{
case 16:
for (int i = 4; i < 12; i++)
sb.Append(hashValue[i].ToString("x2"));
break;
case 32:
for (int i = 0; i < 16; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
default:
for (int i = 0; i < hashValue.Length; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
}
return sb.ToString();
}
/// <summary>
/// UTF-8的MD5加密方法
/// </summary>
/// <param name="strSource"></param>
/// <param name="length"></param>
/// <returns></returns>
public static string EncryptMD5UTF8(string strSource, int length = 32)
{
byte[] bytes = Encoding.UTF8.GetBytes(strSource);
byte[] hashValue =
((HashAlgorithm)
CryptoConfig.CreateFromName("MD5")).ComputeHash(bytes);
var sb = new StringBuilder();
switch (length)
{
case 16:
for (int i = 4; i < 12; i++)
sb.Append(hashValue[i].ToString("x2"));
break;
case 32:
for (int i = 0; i < 16; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
default:
for (int i = 0; i < hashValue.Length; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
}
return sb.ToString();
}
#region 3DES加密
/// <summary>
/// 加密字符串
/// </summary>
/// <param name="encryptStr"></param>
/// <returns></returns>
public static string Encrypt3DES(string encryptStr ,Encoding encoding, string privateKey)
{
if (string.IsNullOrEmpty(encryptStr)) return string.Empty;
using (SymmetricAlgorithm algorithm = new TripleDESCryptoServiceProvider())
{
algorithm.Key = encoding.GetBytes(privateKey);
algorithm.Mode = CipherMode.ECB;
algorithm.Padding = PaddingMode.PKCS7;
var transform = algorithm.CreateEncryptor();
var bytes = encoding.GetBytes(encryptStr);
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write))
{
cryptoStream.Write(bytes, 0, bytes.Length);
cryptoStream.FlushFinalBlock();
return Convert.ToBase64String(memoryStream.ToArray());
}
}
}
}
/// <summary>
/// 解密字符串
/// </summary>
/// <param name="decryptStr"></param>
/// <returns></returns>
public static string Decrypt3DES(string decryptStr, Encoding encoding, string privateKey)
{
if (string.IsNullOrEmpty(decryptStr)) return string.Empty;
using (SymmetricAlgorithm algorithm = new TripleDESCryptoServiceProvider())
{
algorithm.Key = encoding.GetBytes(privateKey);
algorithm.Mode = CipherMode.ECB;
algorithm.Padding = PaddingMode.PKCS7;
using (var transform = algorithm.CreateDecryptor(algorithm.Key, algorithm.IV))
{
var bytes = Convert.FromBase64String(decryptStr);
using (var memoryStream = new MemoryStream(bytes))
{
using (var cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Read))
{
using (var reader = new StreamReader(cryptoStream, encoding))
{
return reader.ReadToEnd();
}
}
}
}
}
}
/// <summary>
/// 签名，连接biz_content， charset， merchant_code， method， timestamp， version，$private_key， 然后进行SHA256加密，不可逆转
/// </summary>
/// <param name="str">string str:被加密的字符串</param>
/// <returns>返回加密后的字符串</returns>
public static string Sign(string str,string privateKey)
{
using (var sha = new SHA256Managed())
{
var byteHash = sha.ComputeHash(Encoding.UTF8.GetBytes(str + privateKey));
return BitConverter.ToString(byteHash).Replace("-", "").ToLower();
}
}
#endregion
#region FTP字段加密
/// <summary>
/// FTP（身份证，手机号）加密
/// </summary>
/// <param name="inputstring">加密字段</param>
/// <param name="inputkey">秘钥</param>
/// <returns></returns>
public static long FtpEncypt(int inputstring, int inputkey)
{
return inputstring ^ inputkey;
}
#endregion
}
}
