C# 用C检测破坏性SQL查询#

因此，在我编写的这段C#代码中，我希望找到一种更有效的方法来确定数组中字符串的所有变体。我可以循环整个字符串，将sqltext中的每个字符与前面的字符进行比较，使其过于复杂，或者我可以尝试学习一些新的东西。我在想必须有一个更有效的方法。我向一位同事展示了这个，她建议我使用正则表达式。我研究了一下正则表达式，但似乎找不到正确的表达式

我要寻找的是一个版本，它在代码中采用数组索引的所有变体：

public bool securitycheck(String sqltext)
        {
            string[] badSqlList = new string[] {"insert","Insert","INSERT",
                                                "update","Update","UPDATE",
                                                "delete","Delete","DELETE",
                                                "drop","Drop", "DROP"};
            for (int i = 0; i < badSqlList.Count(); i++)
            {
                if (sqltext.Contains(badSqlList[i]) == true)
                {
                    return true;
                }
            }
            return false;
        }

public bool securitycheck（字符串sqltext）
{
string[]badSqlList=新字符串[]{“插入”、“插入”、“插入”，
“更新”、“更新”、“更新”，
“删除”、“删除”、“删除”，
“滴”、“滴”、“滴”}；
对于（int i=0；i

但考虑到其他拼写。例如，这段代码没有考虑“iNsert、UpDate、dELETE、DrOP”，但据我的同事说，有一种方法可以使用正则表达式来考虑这一点

你认为最好的方法是什么

[更新]

谢谢大家，这里有很多非常好的信息，这确实让我对以编程方式处理SQL大开眼界。我正在构建的这个工具的作用域非常小，任何有权访问这个工具并且有恶意意图的人都可能是直接访问数据库的人。这些检查或多或少是为了防止懒惰。用例不允许参数化查询，否则我会这样做。你的见解很有教育意义，我感谢你的帮助

您可以执行以下操作：

if (badSqlList.Any(r => sqltext.IndexOf(r, StringComparison.InvariantCultureIgnoreCase) >= 0))
{
    //bad SQL found
}

带有

StringComparison

enum值的

IndexOf

将确保不区分大小写的比较

另一种办法可以是：

return sqltext.Split()
        .Intersect(badSqlList,StringComparer.InvariantCultureIgnoreCase)
        .Any()

将Sql拆分为空白，然后将每个单词与白名单数组进行比较。如果您的合法表名包含关键字，如
INESRTEDStudents


不太确定您的需求，但一般来说，更好的选择是首先使用参数化查询。你不能百分之百地确定你的白名单，仍然有办法绕过它
 您可以执行以下操作：

if (badSqlList.Any(r => sqltext.IndexOf(r, StringComparison.InvariantCultureIgnoreCase) >= 0))
{
    //bad SQL found
}

带有
StringComparison
enum值的
IndexOf
将确保不区分大小写的比较

另一种办法可以是：

return sqltext.Split()
        .Intersect(badSqlList,StringComparer.InvariantCultureIgnoreCase)
        .Any()

将Sql拆分为空白，然后将每个单词与白名单数组进行比较。如果您的合法表名包含关键字，如
INESRTEDStudents


不太确定您的需求，但一般来说，更好的选择是首先使用参数化查询。你不能百分之百地确定你的白名单，仍然有办法绕过它
 您可以执行以下操作：

if (badSqlList.Any(r => sqltext.IndexOf(r, StringComparison.InvariantCultureIgnoreCase) >= 0))
{
    //bad SQL found
}

带有
StringComparison
enum值的
IndexOf
将确保不区分大小写的比较

另一种办法可以是：

return sqltext.Split()
        .Intersect(badSqlList,StringComparer.InvariantCultureIgnoreCase)
        .Any()

将Sql拆分为空白，然后将每个单词与白名单数组进行比较。如果您的合法表名包含关键字，如
INESRTEDStudents


不太确定您的需求，但一般来说，更好的选择是首先使用参数化查询。你不能百分之百地确定你的白名单，仍然有办法绕过它
 您可以执行以下操作：

if (badSqlList.Any(r => sqltext.IndexOf(r, StringComparison.InvariantCultureIgnoreCase) >= 0))
{
    //bad SQL found
}

带有
StringComparison
enum值的
IndexOf
将确保不区分大小写的比较

另一种办法可以是：

return sqltext.Split()
        .Intersect(badSqlList,StringComparer.InvariantCultureIgnoreCase)
        .Any()

将Sql拆分为空白，然后将每个单词与白名单数组进行比较。如果您的合法表名包含关键字，如
INESRTEDStudents


不太确定您的需求，但一般来说，更好的选择是首先使用参数化查询。你不能百分之百地确定你的白名单，仍然有办法绕过它
 不要重新发明轮子-只要使用参数化查询，就像这里的每个人告诉你的那样（修复了比你现在意识到的更多的问题），你会像所有人一样感谢未来

但一定要用它来清理
WHERE
子句中的所有筛选字符串：

    public static string EscapeSpecial(string s)
    {
        Contract.Requires(s != null);

        var sb = new StringBuilder();
        foreach(char c in s)
        {
            switch(c)
            {
                case '[':
                case ']':
                case '%':
                case '*':
                {
                    sb.AppendFormat(CultureInfo.InvariantCulture, "[{0}]", c);
                    break;
                }
                case '\'':
                {
                    sb.Append("''");
                    break;
                }
                default:
                {
                    sb.Append(c);
                    break;
                }
            }
        }
        return sb.ToString();
    }

不要重新发明轮子-只要使用参数化查询，就像这里的每个人告诉你的那样（修复了比你现在意识到的更多的问题），你将在将来感谢所有人

但一定要用它来清理
WHERE
子句中的所有筛选字符串：

    public static string EscapeSpecial(string s)
    {
        Contract.Requires(s != null);

        var sb = new StringBuilder();
        foreach(char c in s)
        {
            switch(c)
            {
                case '[':
                case ']':
                case '%':
                case '*':
                {
                    sb.AppendFormat(CultureInfo.InvariantCulture, "[{0}]", c);
                    break;
                }
                case '\'':
                {
                    sb.Append("''");
                    break;
                }
                default:
                {
                    sb.Append(c);
                    break;
                }
            }
        }
        return sb.ToString();
    }

不要重新发明轮子-只要使用参数化查询，就像这里的每个人告诉你的那样（修复了比你现在意识到的更多的问题），你将在将来感谢所有人

但一定要用它来清理
WHERE
子句中的所有筛选字符串：

    public static string EscapeSpecial(string s)
    {
        Contract.Requires(s != null);

        var sb = new StringBuilder();
        foreach(char c in s)
        {
            switch(c)
            {
                case '[':
                case ']':
                case '%':
                case '*':
                {
                    sb.AppendFormat(CultureInfo.InvariantCulture, "[{0}]", c);
                    break;
                }
                case '\'':
                {
                    sb.Append("''");
                    break;
                }
                default:
                {
                    sb.Append(c);
                    break;
                }
            }
        }
        return sb.ToString();
    }

不要重新发明轮子-只要使用参数化查询，就像这里的每个人告诉你的那样（修复了比你现在意识到的更多的问题），你将在将来感谢所有人

但一定要用它来清理
WHERE
子句中的所有筛选字符串：

    public static string EscapeSpecial(string s)
    {
        Contract.Requires(s != null);

        var sb = new StringBuilder();
        foreach(char c in s)
        {
            switch(c)
            {
                case '[':
                case ']':
                case '%':
                case '*':
                {
                    sb.AppendFormat(CultureInfo.InvariantCulture, "[{0}]", c);
                    break;
                }
                case '\'':
                {
                    sb.Append("''");
                    break;
                }
                default:
                {
                    sb.Append(c);
                    break;
                }
            }
        }
        return sb.ToString();
    }

如果您将输入文本转换为小写，您需要检查的关键字很少，拼写排列也没有问题。您到底想做什么？只需使用参数化查询，问题就解决了。我会使用参数化查询…但我