Verhindern von SQL-Injection mit Raw SQL und ORM in Golang

Sichere Golang-Datenbankinteraktionen: SQL-Injection verhindern

In der heutigen Entwicklungslandschaft sind sichere Codierungspraktiken von größter Bedeutung. Dieser Artikel konzentriert sich auf den Schutz von Golang-Anwendungen vor SQL-Injection-Schwachstellen, einer häufigen Bedrohung bei der Interaktion mit Datenbanken. Wir werden Präventionstechniken untersuchen, die sowohl Roh-SQL als auch ORM-Frameworks (Object-Relational Mapping) verwenden.

---

SQL-Injection verstehen

SQL-Injection (SQLi) ist eine kritische Web-Sicherheitslücke. Angreifer nutzen es aus, indem sie bösartigen SQL-Code in Datenbankabfragen einschleusen und so möglicherweise die Datenintegrität und Anwendungssicherheit gefährden.

Ein Beispiel für eine anfällige Abfrage:

<code class="language-go">query := "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'"
rows, err := db.Query(query)</code>

Böswillige Eingaben in username oder password können die Logik der Abfrage ändern.

Ein tieferes Verständnis der SQL-Injection finden Sie in diesem anderen Beitrag.

---

Sichern von Raw-SQL-Abfragen

Wenn Sie direkt mit SQL arbeiten, priorisieren Sie diese Sicherheitsmaßnahmen:

1. Vorbereitete Anweisungen: Das database/sql-Paket von Go bietet vorbereitete Anweisungen, eine entscheidende Verteidigung gegen SQLi.

Gefährdetes Beispiel:

<code class="language-go">query := "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'"
rows, err := db.Query(query) // Vulnerable to SQL injection</code>

Sichere Version (vorbereitete Erklärung):

<code class="language-go">query := "SELECT * FROM users WHERE username = ? AND password = ?"
rows, err := db.Query(query, username, password)
if err != nil {
    log.Fatal(err)
}</code>

Vorbereitete Anweisungen entziehen Benutzereingaben automatisch und verhindern so eine Injektion.

2. Parametrisierte Abfragen: Verwenden Sie db.Query oder db.Exec mit Platzhaltern für parametrisierte Abfragen:

<code class="language-go">query := "INSERT INTO products (name, price) VALUES (?, ?)"
_, err := db.Exec(query, productName, productPrice)
if err != nil {
    log.Fatal(err)
}</code>

Vermeiden Sie die Verkettung von Zeichenfolgen oder fmt.Sprintf für dynamische Abfragen.

3. QueryRowfür einzelne Datensätze:Für den Einzelzeilenabruf QueryRowminimiert das Risiko:

<code class="language-go">query := "SELECT id, name FROM users WHERE email = ?"
var id int
var name string
err := db.QueryRow(query, email).Scan(&id, &name)
if err != nil {
    log.Fatal(err)
}</code>

4. Eingabevalidierung und -bereinigung: Validieren und bereinigen Sie Eingaben auch bei vorbereiteten Anweisungen:

• Bereinigung:Entfernt unerwünschte Zeichen.
• Validierung:Überprüft Eingabeformat, Typ und Länge.

Go-Eingabevalidierungsbeispiel:

<code class="language-go">func isValidUsername(username string) bool {
    re := regexp.MustCompile(`^[a-zA-Z0-9_]+$`)
    return re.MatchString(username)
}

if len(username) > 50 || !isValidUsername(username) {
    log.Fatal("Invalid input")
}</code>

5. Gespeicherte Prozeduren: Abfragelogik in gespeicherten Datenbankprozeduren kapseln:

<code class="language-sql">CREATE PROCEDURE AuthenticateUser(IN username VARCHAR(50), IN password VARCHAR(50))
BEGIN
    SELECT * FROM users WHERE username = username AND password = password;
END;</code>

Anruf von unterwegs:

<code class="language-go">_, err := db.Exec("CALL AuthenticateUser(?, ?)", username, password)
if err != nil {
    log.Fatal(err)
}</code>

---

SQL-Injection mit ORMs verhindern

ORMs wie GORM und XORM vereinfachen Datenbankinteraktionen, aber sichere Praktiken sind immer noch wichtig.

1. GORM:

Anfälliges Beispiel (dynamische Abfrage):

<code class="language-go">db.Raw("SELECT * FROM users WHERE name = '" + userName + "'").Scan(&user)</code>

Sicheres Beispiel (parametrisierte Abfrage):

<code class="language-go">db.Raw("SELECT * FROM users WHERE name = ? AND email = ?", userName, email).Scan(&user)</code>

GORMs Raw-Methode unterstützt Platzhalter. Bevorzugen Sie die integrierten Methoden von GORM wie Where:

<code class="language-go">query := "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'"
rows, err := db.Query(query)</code>

2. Vermeiden Sie Roh-SQL für komplexe Abfragen:Verwenden Sie Platzhalter auch bei komplexen Rohabfragen.

3. Struktur-Tags für sicheres Mapping: Verwenden Sie Struktur-Tags für sicheres ORM-Mapping:

<code class="language-go">query := "SELECT * FROM users WHERE username='" + username + "' AND password='" + password + "'"
rows, err := db.Query(query) // Vulnerable to SQL injection</code>

Häufig zu vermeidende Fehler:

1. Vermeiden Sie die Verkettung von Zeichenfolgen in Abfragen.
2. Vermeiden Sie, dass ORM-Funktionen Sicherheitsprüfungen umgehen.
3. Vertrauen Sie niemals Benutzereingaben ohne Validierung.

---

Fazit

Golang bietet robuste Tools für eine sichere Datenbankinteraktion. Durch die korrekte Verwendung von vorbereiteten Anweisungen, parametrisierten Abfragen und ORMs sowie die sorgfältige Validierung und Bereinigung von Benutzereingaben reduzieren Sie das Risiko von SQL-Injection-Schwachstellen erheblich.

Verbinden Sie sich mit mir unter:

• LinkedIn
• GitHub
• Twitter/X

Das obige ist der detaillierte Inhalt vonVerhindern von SQL-Injection mit Raw SQL und ORM in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!