CA2100: Granska SQL-frågor om säkerhetsrisker

Property	Värde
Regel-ID	CA2100
Title	Granska SQL-frågor för säkerhetsrisker
Kategori	Säkerhet
Korrigeringen är icke-bakåtkompatibel	Icke-icke-bryta
Aktiverad som standard i .NET 8	Nej

Orsak

En metod anger System.Data.IDbCommand.CommandText egenskapen med hjälp av en sträng som skapas från ett strängargument till metoden.

Som standard analyserar den här regeln hela kodbasen, men detta kan konfigureras.

Regelbeskrivning

Den här regeln förutsätter att alla strängar, vars värde inte kan fastställas vid kompileringstillfället, kan innehålla användarindata. En SQL-kommandosträng som skapas från användarindata är sårbar för SQL-inmatningsattacker. I en SQL-inmatningsattack tillhandahåller en obehörig användare indata som ändrar utformningen av en fråga i ett försök att skada eller få obehörig åtkomst till den underliggande databasen. Typiska tekniker är inmatning av ett enkelt citattecken eller apostrofer, vilket är sql literal string delimiter; två bindestreck, vilket betyder en SQL-kommentar; och ett semikolon, vilket indikerar att ett nytt kommando följer. Om användarindata måste ingå i frågan använder du något av följande, som anges i ordningsföljd, för att minska risken för angrepp.

• Använd en lagrad procedur.

• Använd en parameteriserad kommandosträng.

• Verifiera användarindata för både typ och innehåll innan du skapar kommandosträngen.

Följande .NET-typer implementerar CommandText egenskapen eller tillhandahåller konstruktorer som anger egenskapen med hjälp av ett strängargument.

• System.Data.Odbc.OdbcCommand och System.Data.Odbc.OdbcDataAdapter

• System.Data.OleDb.OleDbCommand och System.Data.OleDb.OleDbDataAdapter

• System.Data.OracleClient.OracleCommand och System.Data.OracleClient.OracleDataAdapter

• System.Data.SqlClient.SqlCommand och System.Data.SqlClient.SqlDataAdapter

I vissa fall kanske den här regeln inte fastställer en strängs värde vid kompileringstillfället, även om du kan. I dessa fall ger den här regeln falska positiva identifieringar när du använder dessa strängar som SQL-kommandon. Följande är ett exempel på en sådan sträng.

int x = 10;
string query = "SELECT TOP " + x.ToString() + " FROM Table";

Samma sak gäller när du använder ToString() implicit.

int x = 10;
string query = String.Format("SELECT TOP {0} FROM Table", x);

Så här åtgärdar du överträdelser

Om du vill åtgärda ett brott mot den här regeln använder du en parametriserad fråga.

När du ska ignorera varningar

Det är säkert att ignorera en varning från den här regeln om kommandotexten inte innehåller några användarindata.

Ignorera en varning

Om du bara vill förhindra en enda överträdelse lägger du till förprocessordirektiv i källfilen för att inaktivera och aktiverar sedan regeln igen.

#pragma warning disable CA2100
// The code that's violating the rule is on this line.
#pragma warning restore CA2100

Om du vill inaktivera regeln för en fil, mapp eller ett projekt anger du dess allvarlighetsgrad till none i konfigurationsfilen.

[*.{cs,vb}]
dotnet_diagnostic.CA2100.severity = none

Mer information finns i Så här utelämnar du kodanalysvarningar.

Konfigurera kod för analys

Använd följande alternativ för att konfigurera vilka delar av kodbasen som regeln ska köras på.

• Exkludera specifika symboler
• Exkludera specifika typer och deras härledda typer

Du kan konfigurera dessa alternativ för bara den här regeln, för alla regler som den gäller för eller för alla regler i den här kategorin (säkerhet) som den gäller för. Mer information finns i Konfigurationsalternativ för kodkvalitetsregel.

Exkludera specifika symboler

Du kan exkludera specifika symboler, till exempel typer och metoder, från analys. Om du till exempel vill ange att regeln inte ska köras på någon kod inom typer med namnet MyTypelägger du till följande nyckel/värde-par i en .editorconfig-fil i projektet:

dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType

Tillåtna symbolnamnformat i alternativvärdet (avgränsade med |):

• Endast symbolnamn (innehåller alla symboler med namnet, oavsett vilken typ eller namnrymd som innehåller).
• Fullständigt kvalificerade namn i symbolens dokumentations-ID-format. Varje symbolnamn kräver ett symboltypprefix, till exempel M: för metoder, T: för typer och N: för namnområden.
• .ctor för konstruktorer och .cctor statiska konstruktorer.

Exempel:

Alternativvärde	Sammanfattning
dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType	Matchar alla symboler med namnet MyType.
dotnet_code_quality.CAXXXX.excluded_symbol_names = MyType1|MyType2	Matchar alla symboler med namnet antingen MyType1 eller MyType2.
dotnet_code_quality.CAXXXX.excluded_symbol_names = M:NS.MyType.MyMethod(ParamType)	Matchar en specifik metod MyMethod med den angivna fullständigt kvalificerade signaturen.
dotnet_code_quality.CAXXXX.excluded_symbol_names = M:NS1.MyType1.MyMethod1(ParamType)|M:NS2.MyType2.MyMethod2(ParamType)	Matchar specifika metoder MyMethod1 och MyMethod2 med respektive fullständigt kvalificerade signaturer.

Exkludera specifika typer och deras härledda typer

Du kan exkludera specifika typer och deras härledda typer från analys. Om du till exempel vill ange att regeln inte ska köras på några metoder inom typer som heter MyType och deras härledda typer lägger du till följande nyckel/värde-par i en .editorconfig-fil i projektet:

dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType

Tillåtna symbolnamnformat i alternativvärdet (avgränsade med |):

• Skriv endast namn (innehåller alla typer med namnet, oavsett vilken typ eller namnrymd som innehåller).
• Fullständigt kvalificerade namn i symbolens dokumentations-ID-format, med ett valfritt T: prefix.

Exempel:

Alternativvärde	Sammanfattning
dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType	Matchar alla typer med namnet MyType och alla deras härledda typer.
dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = MyType1|MyType2	Matchar alla typer med namnet antingen MyType1 eller MyType2 och alla deras härledda typer.
dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = M:NS.MyType	Matchar en specifik typ MyType med ett angivet fullständigt kvalificerat namn och alla dess härledda typer.
dotnet_code_quality.CAXXXX.excluded_type_names_with_derived_types = M:NS1.MyType1|M:NS2.MyType2	Matchar specifika typer MyType1 och MyType2 med respektive fullständigt kvalificerade namn och alla deras härledda typer.

Exempel

I följande exempel visas en metod, UnsafeQuery, som bryter mot regeln och en metod, SaferQuery, som uppfyller regeln med hjälp av en parameteriserad kommandosträng.

Imports System
Imports System.Data
Imports System.Data.SqlClient

Namespace ca2100

    Public Class SqlQueries

        Function UnsafeQuery(connection As String,
         name As String, password As String) As Object

            Dim someConnection As New SqlConnection(connection)
            Dim someCommand As New SqlCommand()
            someCommand.Connection = someConnection

            someCommand.CommandText = "SELECT AccountNumber FROM Users " &
            "WHERE Username='" & name & "' AND Password='" & password & "'"

            someConnection.Open()
            Dim accountNumber As Object = someCommand.ExecuteScalar()
            someConnection.Close()
            Return accountNumber

        End Function

        Function SaferQuery(connection As String,
         name As String, password As String) As Object

            Dim someConnection As New SqlConnection(connection)
            Dim someCommand As New SqlCommand()
            someCommand.Connection = someConnection

            someCommand.Parameters.Add(
            "@username", SqlDbType.NChar).Value = name
            someCommand.Parameters.Add(
            "@password", SqlDbType.NChar).Value = password
            someCommand.CommandText = "SELECT AccountNumber FROM Users " &
            "WHERE Username=@username AND Password=@password"

            someConnection.Open()
            Dim accountNumber As Object = someCommand.ExecuteScalar()
            someConnection.Close()
            Return accountNumber

        End Function

    End Class

    Class MaliciousCode

        Shared Sub Main2100(args As String())

            Dim queries As New SqlQueries()
            queries.UnsafeQuery(args(0), "' OR 1=1 --", "[PLACEHOLDER]")
            ' Resultant query (which is always true):
            ' SELECT AccountNumber FROM Users WHERE Username='' OR 1=1

            queries.SaferQuery(args(0), "' OR 1=1 --", "[PLACEHOLDER]")
            ' Resultant query (notice the additional single quote character):
            ' SELECT AccountNumber FROM Users WHERE Username=''' OR 1=1 --'
            '                                   AND Password='[PLACEHOLDER]'
        End Sub

    End Class

End Namespace

public class SqlQueries
{
    public object UnsafeQuery(
       string connection, string name, string password)
    {
        SqlConnection someConnection = new SqlConnection(connection);
        SqlCommand someCommand = new SqlCommand();
        someCommand.Connection = someConnection;

        someCommand.CommandText = "SELECT AccountNumber FROM Users " +
           "WHERE Username='" + name +
           "' AND Password='" + password + "'";

        someConnection.Open();
        object accountNumber = someCommand.ExecuteScalar();
        someConnection.Close();
        return accountNumber;
    }

    public object SaferQuery(
       string connection, string name, string password)
    {
        SqlConnection someConnection = new SqlConnection(connection);
        SqlCommand someCommand = new SqlCommand();
        someCommand.Connection = someConnection;

        someCommand.Parameters.Add(
           "@username", SqlDbType.NChar).Value = name;
        someCommand.Parameters.Add(
           "@password", SqlDbType.NChar).Value = password;
        someCommand.CommandText = "SELECT AccountNumber FROM Users " +
           "WHERE Username=@username AND Password=@password";

        someConnection.Open();
        object accountNumber = someCommand.ExecuteScalar();
        someConnection.Close();
        return accountNumber;
    }
}

class MaliciousCode
{
    static void Main2100(string[] args)
    {
        SqlQueries queries = new SqlQueries();
        queries.UnsafeQuery(args[0], "' OR 1=1 --", "[PLACEHOLDER]");
        // Resultant query (which is always true):
        // SELECT AccountNumber FROM Users WHERE Username='' OR 1=1

        queries.SaferQuery(args[0], "' OR 1=1 --", "[PLACEHOLDER]");
        // Resultant query (notice the additional single quote character):
        // SELECT AccountNumber FROM Users WHERE Username=''' OR 1=1 --'
        //                                   AND Password='[PLACEHOLDER]'
    }
}

Se även

• Säkerhetsöversikt