From 3b317f7eefba357d0f7b1636bff3fd3a848b6cf1 Mon Sep 17 00:00:00 2001 From: adawang Date: Tue, 16 Jun 2026 17:14:42 +0800 Subject: [PATCH] perf(utils): compile SQL-validation regexps once instead of per call MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit checkSQLInjectionRisks and InjectAndConditions compiled their regexps with regexp.MustCompile on every invocation. Both run on the datasource SQL path — InjectAndConditions is called once per security filter (tenant, soft-delete, hidden-KB, search-scope), so a single secured query recompiled ~20 patterns. InjectAndConditions also compiled the identical tail-clause pattern twice. Hoist them to package-level vars (compiled once at init). Behavior is unchanged — same patterns, covered by the existing TestValidateSQL_* and TestInjectAndConditions tests. Benchmarks (apple M, -benchmem): InjectAndConditions 4347 ns, 72 allocs -> 1023 ns, 7 allocs checkSQLInjectionRisks 36074 ns, 560 allocs -> 12984 ns, 12 allocs Co-Authored-By: Claude Opus 4.8 --- internal/utils/inject.go | 80 ++++++++++++++++++++--------------- internal/utils/inject_test.go | 14 ++++++ 2 files changed, 61 insertions(+), 33 deletions(-) diff --git a/internal/utils/inject.go b/internal/utils/inject.go index 5759a784..8a31f83e 100644 --- a/internal/utils/inject.go +++ b/internal/utils/inject.go @@ -908,6 +908,14 @@ func collectTableAliases(node *pg_query.Node, m map[string]string) { // InjectAndConditions injects filter conditions into a SQL statement using AND semantics. // If WHERE exists, the original WHERE predicates will be wrapped in parentheses. +// Compiled once: the WHERE keyword and the set of clauses that may trail a +// WHERE expression. reSQLTailClause is shared by InjectAndConditions for both +// "where does the WHERE expression end" and "where to insert a new WHERE". +var ( + reSQLWhereKeyword = regexp.MustCompile(`(?i)\bWHERE\b`) + reSQLTailClause = regexp.MustCompile(`(?i)\b(GROUP BY|ORDER BY|LIMIT|OFFSET|HAVING|FETCH)\b`) +) + func InjectAndConditions(sql, filter string) string { filter = strings.TrimSpace(filter) if filter == "" { @@ -915,14 +923,12 @@ func InjectAndConditions(sql, filter string) string { } // Check if WHERE clause exists - wherePattern := regexp.MustCompile(`(?i)\bWHERE\b`) - if loc := wherePattern.FindStringIndex(sql); loc != nil { + if loc := reSQLWhereKeyword.FindStringIndex(sql); loc != nil { // Add filter and wrap existing conditions in parentheses to prevent OR precedence issues. // The wrapping must only apply to the original WHERE expression, not trailing clauses like // ORDER BY / GROUP BY / LIMIT, otherwise it can generate invalid SQL. whereExprStart := loc[1] - tailPattern := regexp.MustCompile(`(?i)\b(GROUP BY|ORDER BY|LIMIT|OFFSET|HAVING|FETCH)\b`) - tailLoc := tailPattern.FindStringIndex(sql[whereExprStart:]) + tailLoc := reSQLTailClause.FindStringIndex(sql[whereExprStart:]) if tailLoc == nil { originalWhereExpr := strings.TrimSpace(sql[whereExprStart:]) @@ -936,8 +942,7 @@ func InjectAndConditions(sql, filter string) string { } // Add new WHERE clause before ORDER BY, GROUP BY, LIMIT, etc. - clausePattern := regexp.MustCompile(`(?i)\b(GROUP BY|ORDER BY|LIMIT|OFFSET|HAVING|FETCH)\b`) - if loc := clausePattern.FindStringIndex(sql); loc != nil { + if loc := reSQLTailClause.FindStringIndex(sql); loc != nil { prefix := strings.TrimRight(sql[:loc[0]], " \t\r\n") suffix := strings.TrimLeft(sql[loc[0]:], " \t\r\n") return fmt.Sprintf("%s WHERE %s %s", prefix, filter, suffix) @@ -1054,20 +1059,13 @@ func quoteStringSlice(ss []string) []string { return quoted } -// checkSQLInjectionRisks checks for common SQL injection patterns in WHERE clause -func checkSQLInjectionRisks(whereClause string) []SQLValidationError { - errors := make([]SQLValidationError, 0) +// Compiled once. checkSQLInjectionRisks runs on every validated WHERE clause, +// so these patterns are hoisted to package scope instead of being recompiled +// per call. +var ( + reSQLWhitespace = regexp.MustCompile(`\s+`) - if whereClause == "" { - return errors - } - - // Normalize the WHERE clause for checking - normalizedWhere := strings.ToLower(strings.TrimSpace(whereClause)) - normalizedWhere = regexp.MustCompile(`\s+`).ReplaceAllString(normalizedWhere, " ") - - // Pattern 1: Always true conditions like "1=1", "'1'='1'", "true", etc. - alwaysTruePatterns := []struct { + sqlAlwaysTruePatterns = []struct { pattern *regexp.Regexp description string }{ @@ -1089,18 +1087,7 @@ func checkSQLInjectionRisks(whereClause string) []SQLValidationError { }, } - for _, pt := range alwaysTruePatterns { - if pt.pattern.MatchString(normalizedWhere) { - errors = append(errors, SQLValidationError{ - Type: "sql_injection_risk", - Message: "Potential SQL injection risk detected", - Details: fmt.Sprintf("%s found in WHERE clause: %s", pt.description, whereClause), - }) - } - } - - // Pattern 2: Always false conditions that might be used for testing - alwaysFalsePatterns := []struct { + sqlAlwaysFalsePatterns = []struct { pattern *regexp.Regexp description string }{ @@ -1114,7 +1101,34 @@ func checkSQLInjectionRisks(whereClause string) []SQLValidationError { }, } - for _, pt := range alwaysFalsePatterns { + reSQLOrAlwaysTrue = regexp.MustCompile(`or\s+(1\s*=\s*1|'1'\s*=\s*'1'|true)`) +) + +// checkSQLInjectionRisks checks for common SQL injection patterns in WHERE clause +func checkSQLInjectionRisks(whereClause string) []SQLValidationError { + errors := make([]SQLValidationError, 0) + + if whereClause == "" { + return errors + } + + // Normalize the WHERE clause for checking + normalizedWhere := strings.ToLower(strings.TrimSpace(whereClause)) + normalizedWhere = reSQLWhitespace.ReplaceAllString(normalizedWhere, " ") + + // Pattern 1: Always true conditions like "1=1", "'1'='1'", "true", etc. + for _, pt := range sqlAlwaysTruePatterns { + if pt.pattern.MatchString(normalizedWhere) { + errors = append(errors, SQLValidationError{ + Type: "sql_injection_risk", + Message: "Potential SQL injection risk detected", + Details: fmt.Sprintf("%s found in WHERE clause: %s", pt.description, whereClause), + }) + } + } + + // Pattern 2: Always false conditions that might be used for testing + for _, pt := range sqlAlwaysFalsePatterns { if pt.pattern.MatchString(normalizedWhere) { errors = append(errors, SQLValidationError{ Type: "sql_injection_risk", @@ -1125,7 +1139,7 @@ func checkSQLInjectionRisks(whereClause string) []SQLValidationError { } // Pattern 3: OR with always-true condition (common injection pattern) - if regexp.MustCompile(`or\s+(1\s*=\s*1|'1'\s*=\s*'1'|true)`).MatchString(normalizedWhere) { + if reSQLOrAlwaysTrue.MatchString(normalizedWhere) { errors = append(errors, SQLValidationError{ Type: "sql_injection_risk", Message: "High-risk SQL injection pattern detected", diff --git a/internal/utils/inject_test.go b/internal/utils/inject_test.go index c84ec9a2..730c2fe0 100644 --- a/internal/utils/inject_test.go +++ b/internal/utils/inject_test.go @@ -448,3 +448,17 @@ func TestInjectAndConditions(t *testing.T) { }) } } + +func BenchmarkInjectAndConditions(b *testing.B) { + const sql = "SELECT id, title FROM docs WHERE status = 'active' ORDER BY created_at LIMIT 50" + for i := 0; i < b.N; i++ { + _ = InjectAndConditions(sql, "tenant_id = 1") + } +} + +func BenchmarkCheckSQLInjectionRisks(b *testing.B) { + const where = "status = 'active' AND name LIKE '%foo%' AND (deleted_at IS NULL OR archived = false)" + for i := 0; i < b.N; i++ { + _ = checkSQLInjectionRisks(where) + } +}