using System;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Web;
namespace Common
{
public class StringHelper
{
public static void AppendString(StringBuilder sb, string append)
{
StringHelper.AppendString(sb, append, ",");
}
public static void AppendString(StringBuilder sb, string append, string split)
{
if (sb.Length == 0)
{
sb.Append(append);
}
else
{
sb.Append(split);
sb.Append(append);
}
}
public static string Base64StringDecode(string input)
{
return Encoding.UTF8.GetString(Convert.FromBase64String(input));
}
public static string Base64StringEncode(string input)
{
return Convert.ToBase64String(Encoding.UTF8.GetBytes(input));
}
public static bool CheckNodePurview(string arrstr1, string arrstr2)
{
if (!string.IsNullOrEmpty(arrstr1) && !string.IsNullOrEmpty(arrstr2))
{
string[] strArray1 = arrstr1.Split(Convert.ToChar(","));
string[] strArray2 = arrstr2.Split(Convert.ToChar(","));
foreach (string str1 in strArray1)
{
foreach (string str2 in strArray2)
{
if (!string.IsNullOrEmpty(str2.Trim()) && str2.Trim() == str1.Trim())
return true;
}
}
}
return false;
}
public static string CollectionFilter(string conStr, string tagName, int fType)
{
string input = conStr;
switch (fType)
{
case 1:
return Regex.Replace(input, "<" + tagName + "([^>])*>", "", RegexOptions.IgnoreCase);
case 2:
return Regex.Replace(input, "<" + tagName + "([^>])*>.*?" + tagName + "([^>])*>", "", RegexOptions.IgnoreCase);
case 3:
return Regex.Replace(Regex.Replace(input, "<" + tagName + "([^>])*>", "", RegexOptions.IgnoreCase), "" + tagName + "([^>])*>", "", RegexOptions.IgnoreCase);
default:
return input;
}
}
public static string DecodeIP(long ip)
{
return (ip >> 24 & (long) byte.MaxValue).ToString() + "." + (ip >> 16 & (long) byte.MaxValue).ToString() + "." + (ip >> 8 & (long) byte.MaxValue).ToString() + "." + (ip & (long) byte.MaxValue).ToString();
}
public static string DecodeLockIP(string lockIP)
{
StringBuilder stringBuilder = new StringBuilder(256);
if (string.IsNullOrEmpty(lockIP))
return stringBuilder.ToString();
try
{
string str1 = lockIP;
string[] separator1 = new string[1]
{
"$$$"
};
int num1 = 1;
foreach (string str2 in str1.Split(separator1, (StringSplitOptions) num1))
{
string[] separator2 = new string[1]
{
"----"
};
int num2 = 1;
string[] strArray = str2.Split(separator2, (StringSplitOptions) num2);
stringBuilder.Append(StringHelper.DecodeIP(Convert.ToInt64(strArray[0])) + "----" + StringHelper.DecodeIP(Convert.ToInt64(strArray[1])) + "\n");
}
return stringBuilder.ToString().TrimEnd('\n');
}
catch (IndexOutOfRangeException)
{
return stringBuilder.ToString();
}
}
public static double EncodeIP(string sip)
{
if (string.IsNullOrEmpty(sip))
return 0.0;
string[] strArray = sip.Split('.');
long num = 0L;
foreach (string s in strArray)
{
byte result;
if (!byte.TryParse(s, out result))
return 0.0;
num = num << 8 | (long) result;
}
return (double) num;
}
public static string EncodeLockIP(string ipList)
{
StringBuilder stringBuilder = new StringBuilder(256);
if (!string.IsNullOrEmpty(ipList.Trim()))
{
string[] strArray1 = ipList.Split('\n');
for (int index = 0; index < strArray1.Length; ++index)
{
if (!string.IsNullOrEmpty(strArray1[index]) && strArray1[index].Contains("----"))
{
string[] strArray2 = strArray1[index].Split(new string[1]
{
"----"
}, StringSplitOptions.RemoveEmptyEntries);
if (strArray2.Length < 2)
throw new ArgumentException("请填写正确网站黑白名单中的IP地址!");
if (!DataValidate.IsIP(strArray2[0]) || !DataValidate.IsIP(strArray2[1]))
throw new ArgumentException("请填写正确网站黑白名单中的IP地址!");
if (index == 0)
stringBuilder.Append( StringHelper.EncodeIP(strArray2[0]) + "----" + StringHelper.EncodeIP(strArray2[1]));
else
stringBuilder.Append(string.Concat(new object[4]
{
(object) "$$$",
(object) StringHelper.EncodeIP(strArray2[0]),
(object) "----",
(object) StringHelper.EncodeIP(strArray2[1])
}));
}
}
}
return stringBuilder.ToString();
}
public static string FilterScript(string conStr, string filterItem)
{
string str1 = conStr.Replace("\r", "{$Chr13}").Replace("\n", "{$Chr10}");
string str2 = filterItem;
char[] separator = new char[1]
{
','
};
int num = 1;
foreach (string tagName in str2.Split(separator, (StringSplitOptions) num))
{
switch (tagName)
{
case "Iframe":
str1 = StringHelper.CollectionFilter(str1, tagName, 2);
break;
case "Object":
str1 = StringHelper.CollectionFilter(str1, tagName, 2);
break;
case "Script":
str1 = StringHelper.CollectionFilter(str1, tagName, 2);
break;
case "Style":
str1 = StringHelper.CollectionFilter(str1, tagName, 2);
break;
case "Div":
str1 = StringHelper.CollectionFilter(str1, tagName, 3);
break;
case "Span":
str1 = StringHelper.CollectionFilter(str1, tagName, 3);
break;
case "Table":
str1 = StringHelper.CollectionFilter(StringHelper.CollectionFilter(StringHelper.CollectionFilter(StringHelper.CollectionFilter(StringHelper.CollectionFilter(str1, tagName, 3), "Tbody", 3), "Tr", 3), "Td", 3), "Th", 3);
break;
case "Img":
str1 = StringHelper.CollectionFilter(str1, tagName, 1);
break;
case "Font":
str1 = StringHelper.CollectionFilter(str1, tagName, 3);
break;
case "A":
str1 = StringHelper.CollectionFilter(str1, tagName, 3);
break;
case "Html":
str1 = StringHelper.StripTags(str1);
break;
}
}
return str1.Replace("{$Chr13}", "\r").Replace("{$Chr10}", "\n");
}
public static bool FoundCharInArr(string checkStr, string findStr)
{
return StringHelper.FoundCharInArr(checkStr, findStr, ",");
}
public static bool FoundCharInArr(string checkStr, string findStr, string split)
{
bool flag = false;
if (string.IsNullOrEmpty(split))
split = ",";
if (string.IsNullOrEmpty(checkStr))
return false;
if (checkStr.IndexOf(split) != -1)
{
if (findStr.IndexOf(split) != -1)
{
string[] strArray1 = checkStr.Split(Convert.ToChar(split));
string[] strArray2 = findStr.Split(Convert.ToChar(split));
foreach (string strA in strArray1)
{
foreach (string strB in strArray2)
{
if (string.Compare(strA, strB) == 0)
{
flag = true;
break;
}
}
if (flag)
return flag;
}
return flag;
}
string str = checkStr;
char[] chArray = new char[1]
{
Convert.ToChar(split)
};
foreach (string strA in str.Split(chArray))
{
if (string.Compare(strA, findStr) == 0)
return true;
}
return flag;
}
if (string.Compare(checkStr, findStr) == 0)
flag = true;
return flag;
}
public static bool FoundStringInArr(string arr, string toFind, char separator)
{
if (arr.IndexOf(separator) >= 0)
{
string[] strArray = arr.Split('|');
for (int index = 0; index < strArray.Length; ++index)
{
if (toFind.ToLower().IndexOf(strArray[index].ToLower()) >= 0 && strArray[index].ToLower() != "")
return true;
}
}
else if (toFind.ToLower().IndexOf(arr.ToLower()) >= 0 && arr.ToLower() != "")
return true;
return false;
}
public static string[] SplitString(string strContent, string strSplit)
{
strContent.IndexOf(strSplit);
if (strContent.IndexOf(strSplit) >= 0)
return Regex.Split(strContent, strSplit.Replace(".", "\\."));
return new string[1]
{
strContent
};
}
public static string NullToSting(string returnStr)
{
if (string.IsNullOrEmpty(returnStr))
return "";
return returnStr;
}
private static string GetGbkX(string testTxt)
{
if (testTxt.CompareTo("吖") >= 0)
{
if (testTxt.CompareTo("八") < 0)
return "A";
if (testTxt.CompareTo("嚓") < 0)
return "B";
if (testTxt.CompareTo("咑") < 0)
return "C";
if (testTxt.CompareTo("妸") < 0)
return "D";
if (testTxt.CompareTo("发") < 0)
return "E";
if (testTxt.CompareTo("旮") < 0)
return "F";
if (testTxt.CompareTo("铪") < 0)
return "G";
if (testTxt.CompareTo("讥") < 0)
return "H";
if (testTxt.CompareTo("咔") < 0)
return "J";
if (testTxt.CompareTo("垃") < 0)
return "K";
if (testTxt.CompareTo("嘸") < 0)
return "L";
if (testTxt.CompareTo("拏") < 0)
return "M";
if (testTxt.CompareTo("噢") < 0)
return "N";
if (testTxt.CompareTo("妑") < 0)
return "O";
if (testTxt.CompareTo("七") < 0)
return "P";
if (testTxt.CompareTo("亽") < 0)
return "Q";
if (testTxt.CompareTo("仨") < 0)
return "R";
if (testTxt.CompareTo("他") < 0)
return "S";
if (testTxt.CompareTo("哇") < 0)
return "T";
if (testTxt.CompareTo("夕") < 0)
return "W";
if (testTxt.CompareTo("丫") < 0)
return "X";
if (testTxt.CompareTo("帀") < 0)
return "Y";
if (testTxt.CompareTo("咗") < 0)
return "Z";
}
return testTxt;
}
public static string GetInitial(string str)
{
StringBuilder stringBuilder = new StringBuilder();
for (int startIndex = 0; startIndex < str.Length; ++startIndex)
stringBuilder.Append(StringHelper.GetOneIndex(str.Substring(startIndex, 1)));
return stringBuilder.ToString();
}
private static string GetOneIndex(string testTxt)
{
if ((int) Convert.ToChar(testTxt) >= 0 && (int) Convert.ToChar(testTxt) < 256)
return testTxt;
return StringHelper.GetGbkX(testTxt);
}
public static string MD5(string str)
{
byte[] hash = new MD5CryptoServiceProvider().ComputeHash(Encoding.Default.GetBytes(str));
string str1 = "";
for (int index = 0; index < hash.Length; ++index)
str1 += hash[index].ToString("x").PadLeft(2, '0');
return str1;
}
public static string MD5gb2312(string input)
{
using (MD5CryptoServiceProvider cryptoServiceProvider = new MD5CryptoServiceProvider())
return BitConverter.ToString(cryptoServiceProvider.ComputeHash(Encoding.GetEncoding("gb2312").GetBytes(input))).Replace("-", "").ToLower();
}
public static string RemoveXss(string input)
{
string str1;
do
{
str1 = input;
input = Regex.Replace(input, "(*\\w+)[\\x00-\\x20]+;", "$1;");
input = Regex.Replace(input, "(*[0-9A-F]+);*", "$1;", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "&(amp|lt|gt|nbsp|quot);", "&$1;");
input = HttpUtility.HtmlDecode(input);
}
while (str1 != input);
string str2;
do
{
str2 = input;
input = Regex.Replace(input, "(<[^>]+style[\\x00-\\x20]*=[\\x00-\\x20]*[^>]*?)\\\\([^>]*>)", "$1/$2", RegexOptions.IgnoreCase);
}
while (str2 != input);
input = Regex.Replace(input, "[\\x00-\\x08\\x0b-\\x0c\\x0e-\\x19]", "");
input = Regex.Replace(input, "(<[^>]+[\\x00-\\x20\"'/])(on|xmlns)[^>]*>", "$1>", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "([a-z]*)[\\x00-\\x20]*=[\\x00-\\x20]*([`'\"]*)[\\x00-\\x20]*j[\\x00-\\x20]*a[\\x00-\\x20]*v[\\x00-\\x20]*a[\\x00-\\x20]*s[\\x00-\\x20]*c[\\x00-\\x20]*r[\\x00-\\x20]*i[\\x00-\\x20]*p[\\x00-\\x20]*t[\\x00-\\x20]*:", "$1=$2nojavascript...", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "([a-z]*)[\\x00-\\x20]*=[\\x00-\\x20]*([`'\"]*)[\\x00-\\x20]*v[\\x00-\\x20]*b[\\x00-\\x20]*s[\\x00-\\x20]*c[\\x00-\\x20]*r[\\x00-\\x20]*i[\\x00-\\x20]*p[\\x00-\\x20]*t[\\x00-\\x20]*:", "$1=$2novbscript...", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "(<[^>]+style[\\x00-\\x20]*=[\\x00-\\x20]*[^>]*?)/\\*[^>]*\\*/([^>]*>)", "$1$2", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "(<[^>]+)style[\\x00-\\x20]*=[\\x00-\\x20]*([`'\"]*).*expression[\\x00-\\x20]*\\([^>]*>", "$1>", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "(<[^>]+)style[\\x00-\\x20]*=[\\x00-\\x20]*([`'\"]*).*behaviour[^>]*>", "$1>", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "(<[^>]+)style[\\x00-\\x20]*=[\\x00-\\x20]*([`'\"]*).*behavior[^>]*>", "$1>", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "(<[^>]+)style[\\x00-\\x20]*=[\\x00-\\x20]*([`'\"]*).*s[\\x00-\\x20]*c[\\x00-\\x20]*r[\\x00-\\x20]*i[\\x00-\\x20]*p[\\x00-\\x20]*t[\\x00-\\x20]*:*[^>]*>", "$1>", RegexOptions.IgnoreCase);
input = Regex.Replace(input, "*\\w+:\\w[^>]*>", "noxss");
string str3;
do
{
str3 = input;
input = Regex.Replace(input, "*(applet|meta|xml|blink|link|style|script|embed|object|iframe|frame|frameset|ilayer|layer|bgsound|title|base)[^>]*>?", "no$1", RegexOptions.IgnoreCase);
}
while (str3 != input);
return input;
}
public static string ReplaceString(string SourceString, string SearchString, string ReplaceString, bool IsCaseInsensetive)
{
return Regex.Replace(SourceString, Regex.Escape(SearchString), ReplaceString, IsCaseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None);
}
public static string SHA1(string input)
{
using (SHA1CryptoServiceProvider cryptoServiceProvider = new SHA1CryptoServiceProvider())
return BitConverter.ToString(cryptoServiceProvider.ComputeHash(Encoding.UTF8.GetBytes(input))).Replace("-", "").ToLower();
}
public static string StripTags(string input)
{
return new Regex("<([^<]|\n)+?>").Replace(input, "");
}
public static string SubString(string demand, int length, string substitute)
{
if (Encoding.Default.GetBytes(demand).Length <= length)
return demand;
ASCIIEncoding asciiEncoding = new ASCIIEncoding();
length -= Encoding.Default.GetBytes(substitute).Length;
int num = 0;
StringBuilder stringBuilder = new StringBuilder();
byte[] bytes = asciiEncoding.GetBytes(demand);
for (int startIndex = 0; startIndex < bytes.Length; ++startIndex)
{
if ((int) bytes[startIndex] == 63)
num += 2;
else
++num;
if (num <= length)
stringBuilder.Append(demand.Substring(startIndex, 1));
else
break;
}
stringBuilder.Append(substitute);
return stringBuilder.ToString();
}
public static int GetStringLength(string str)
{
return Encoding.Default.GetBytes(str).Length;
}
public static string Trim(string returnStr)
{
if (!string.IsNullOrEmpty(returnStr))
return returnStr.Trim();
return string.Empty;
}
public static bool ValidateMD5(string password, string md5Value)
{
if (string.Compare(password, md5Value) != 0)
return string.Compare(password, md5Value.Substring(8, 16)) == 0;
return true;
}
public static string GetDate()
{
return DateTime.Now.ToString("yyyy-MM-dd");
}
public static string GetDate(string datetimestr, string replacestr)
{
if (datetimestr == null)
return replacestr;
if (datetimestr.Equals(""))
return replacestr;
try
{
datetimestr = Convert.ToDateTime(datetimestr).ToString("yyyy-MM-dd").Replace("1900-01-01", replacestr);
}
catch
{
return replacestr;
}
return datetimestr;
}
public static string GetTime()
{
return DateTime.Now.ToString("HH:mm:ss");
}
public static string GetDateTime()
{
return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
}
public static string GetDateTime(int relativeday)
{
DateTime dateTime = DateTime.Now;
dateTime = dateTime.AddDays((double) relativeday);
return dateTime.ToString("yyyy-MM-dd HH:mm:ss");
}
public static string GetDateTimeF()
{
return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fffffff");
}
public static string GetStandardDateTime(string fDateTime, string formatStr)
{
return Convert.ToDateTime(fDateTime).ToString(formatStr);
}
public static string GetStandardDateTime(string fDateTime)
{
return StringHelper.GetStandardDateTime(fDateTime, "yyyy-MM-dd HH:mm:ss");
}
public static int StrDateDiffSeconds(string Time, int Sec)
{
TimeSpan timeSpan = DateTime.Now - DateTime.Parse(Time).AddSeconds((double) Sec);
if (timeSpan.TotalSeconds > (double) int.MaxValue)
return int.MaxValue;
if (timeSpan.TotalSeconds < (double) int.MinValue)
return int.MinValue;
return (int) timeSpan.TotalSeconds;
}
public static int StrDateDiffMinutes(string time, int minutes)
{
if (time == "" || time == null)
return 1;
TimeSpan timeSpan = DateTime.Now - DateTime.Parse(time).AddMinutes((double) minutes);
if (timeSpan.TotalMinutes > (double) int.MaxValue)
return int.MaxValue;
if (timeSpan.TotalMinutes < (double) int.MinValue)
return int.MinValue;
return (int) timeSpan.TotalMinutes;
}
public DateTime DateAdd(string datepart, double number, DateTime date)
{
switch (datepart)
{
case "yy":
return date.AddYears((int) number);
case "mm":
return date.AddMonths((int) number);
case "dd":
return date.AddDays(number);
case "hh":
return date.AddHours(number);
case "mi":
return date.AddMinutes(number);
case "ss":
return date.AddSeconds(number);
default:
return date;
}
}
public static int StrDateDiffHours(string time, int hours)
{
if (time == "" || time == null)
return 1;
TimeSpan timeSpan = DateTime.Now - DateTime.Parse(time).AddHours((double) hours);
if (timeSpan.TotalHours > (double) int.MaxValue)
return int.MaxValue;
if (timeSpan.TotalHours < (double) int.MinValue)
return int.MinValue;
return (int) timeSpan.TotalHours;
}
public static string StrFormat(string str)
{
string str1;
if (str == null)
{
str1 = "";
}
else
{
str = str.Replace("\r\n", "
");
str = str.Replace("\n", "
");
str1 = str;
}
return str1;
}
public static string TrimEnd(string src, string end)
{
int length1 = src.Length;
int length2 = end.Length;
if (length1 < length2)
return src;
int num = 0;
while (num < length2 && (int) src[length1 - num - 1] == (int) end[length2 - num - 1])
++num;
return src.Substring(0, length1 - num);
}
}
}