samber/cc-skills-golang / skills/golang-security
golang-security
FlaggedSecurity best practices and vulnerability prevention for Golang — injection (SQL, command, XSS), cryptography, path traversal, SSRF and HTTP security headers, cookies, secrets management, memory safety, PII in logs, STRIDE/DREAD threat modeling, plus `gosec` SAST, race detection, and fuzz testing. Apply when writing, reviewing, or auditing Go code for security, or when touching crypto, file or network I/O, secrets, user input, or authentication. Not for non-exploitable defensive bugs such as nil panics or slice aliasing (→ See `samber/cc-skills-golang@golang-safety` skill), dependency vulnerability scanning with govulncheck (→ See `samber/cc-skills-golang@golang-dependency-management` skill), or wiring security scanners into CI pipelines (→ See `samber/cc-skills-golang@golang-continuous-integration` skill).
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 14.0 KB |
| evals/evals.json | config | 49.0 KB |
| references/architecture.md | markdown | 10.4 KB |
| references/checklist.md | markdown | 4.0 KB |
| references/cookies.md | markdown | 4.8 KB |
| references/cryptography.md | markdown | 11.0 KB |
| references/filesystem.md | markdown | 6.8 KB |
| references/injection.md | markdown | 7.3 KB |
| references/logging.md | markdown | 3.9 KB |
| references/memory-safety.md | markdown | 5.1 KB |
| references/network.md | markdown | 6.3 KB |
| references/secrets.md | markdown | 4.8 KB |
| references/third-party.md | markdown | 4.9 KB |
| references/threat-modeling.md | markdown | 8.4 KB |
references/injection.md
View on GitHub# Injection Security Rules
Injection vulnerabilities allow attackers to execute arbitrary code, queries, or commands.
**Rules:**
1. SQL queries MUST use parameterized placeholders — NEVER concatenate user input.
2. Command execution MUST use `exec.Command` with separate args — NEVER shell interpolation.
3. HTML output MUST use `html/template` for automatic escaping.
4. SSRF: outbound URLs MUST be validated against an allowlist.
---
## Table of Contents
- [SQL Injection — Critical](#sql-injection--critical)
- [Dynamic IN clauses](#dynamic-in-clauses)
- [Dynamic column names and ORDER BY](#dynamic-column-names-and-order-by)
- [Dynamic WHERE filters](#dynamic-where-filters)
- [Prefer `sqlx` or `pgx` over raw `database/sql`](#prefer-sqlx-or-pgx-over-raw-databasesql)
- [XPath Injection — High](#xpath-injection--high)
- [Code Injection — Critical](#code-injection--critical)
- [Command Injection — Critical](#command-injection--critical)
- [Template Injection — High](#template-injection--high)
- [Cross-Site Scripting (XSS) — High](#cross-site-scripting-xss--high)
- [HTML Tag Injection — High](#html-tag-injection--high)
- [Server-Side Request Forgery (SSRF) — High](#server-side-request-forgery-ssrf--high)
- [Unsafe Deserialization — Critical](#unsafe-deserialization--critical)
- [CWE References](#cwe-references)
## SQL Injection — Critical
Building SQL queries by concatenating user input. Always use prepared statements with placeholders.
**Bad:**
```go
query := fmt.Sprintf("SELECT * FROM users WHERE name = '%s'", input)
query := "SELECT * FROM users WHERE id = " + id
query := "DELETE FROM orders WHERE id = " + strconv.Itoa(orderID) // safe but inconsistent — use placeholders everywhere
```
**Good:**
```go
// Placeholder syntax varies by driver: $1 (pgx/lib/pq), ? (MySQL/SQLite)
db.QueryRow("SELECT * FROM users WHERE name = $1", input)
db.Exec("DELETE FROM orders WHERE id = $1", orderID)
```
### Dynamic IN clauses
Never build `IN (...)` by joining user strings. Generate numbered placeholders.
**Bad:**
```go
query := fmt.Sprintf("SELECT * FROM users WHERE id IN (%s)", strings.Join(ids, ","))
```
**Good:**
```go
// Build placeholders: $1, $2, $3, ...
placeholders := make([]string, len(ids))
args := make([]any, len(ids))
for i, id := range ids {
placeholders[i] = fmt.Sprintf("$%d", i+1)
args[i] = id
}
query := fmt.Sprintf("SELECT * FROM users WHERE id IN (%s)", strings.Join(placeholders, ","))
rows, err := db.Query(query, args...)
```
With `sqlx`:
```go
query, args, err := sqlx.In("SELECT * FROM users WHERE id IN (?)", ids)
query = db.Rebind(query) // converts ? to $1,$2,... for postgres
rows, err := db.Query(query, args...)
```
### Dynamic column names and ORDER BY
Placeholders only work for **values**, not identifiers (table/column names) or SQL keywords. Allowlist identifiers explicitly.
**Bad:**
```go
query := fmt.Sprintf("SELECT * FROM users ORDER BY %s", sortCol) // SQL injection
```
**Good:**
```go
allowed := map[string]string{
"name": "name", "created": "created_at", "email": "email",
}
col, ok := allowed[sortCol]
if !ok {
col = "created_at"
}
query := fmt.Sprintf("SELECT * FROM users ORDER BY %s", col) // safe: col is from allowlist
```
### Dynamic WHERE filters
Build queries incrementally; parameterize every user-supplied value.
```go
var conditions []string
var args []any
idx := 1
if name != "" {
conditions = append(conditions, fmt.Sprintf("name = $%d", idx))
args = append(args, name)
idx++
}
if minAge > 0 {
conditions = append(conditions, fmt.Sprintf("age >= $%d", idx))
args = append(args, minAge)
idx++
}
query := "SELECT * FROM users"
if len(conditions) > 0 {
query += " WHERE " + strings.Join(conditions, " AND ")
}
rows, err := db.Query(query, args...)
```
### Prefer `sqlx` or `pgx` over raw `database/sql`
Libraries like `sqlx` and `pgx` provide safer ergonomics (named parameters, `IN` clause expansion, struct scanning) while still using prepared statements under the hood. They reduce the temptation to fall back to string concatenation for complex queries.
---
## XPath Injection — High
XPath injection allows manipulation of XML data queries.
**Bad:**
```go
xpathQuery := "//user[@username='" + username + "']" // Vulnerable
```
**Good:**
```go
// Use numeric ID
xpathQuery := fmt.Sprintf("//user[@id='%d']", userID)
// Or parse XML without XPath
```
---
## Code Injection — Critical
Generating code from unvalidated user input.
**Bad:**
```go
template := "func handle" + resourceName + "() {...}" // DON'T
```
**Good:**
```go
// Validate resource name matches whitelist
if !allowedResources[resourceName] {
return errors.New("invalid resource")
}
// Use predefined templates
```
---
## Command Injection — Critical
Passing unvalidated input to shell commands.
**Bad:**
```go
cmd := exec.Command("sh", "-c", "rm -f /tmp/"+filename) // DON'T
```
**Good:**
```go
cmd := exec.Command("rm", "-f", filepath.Join("/tmp", filename))
// Better: validate filename
if filepath.Base(filename) != filename {
return errors.New("invalid filename")
}
```
---
## Template Injection — High
Using untrusted input in templates.
**Bad:**
```go
data := r.URL.Query().Get("user") // Untrusted input
t.Execute(w, data)
```
**Good:**
```go
// Validate input
user := strings.TrimSpace(r.URL.Query().Get("user"))
if !allowedRoles[role] {
role = "user"
}
t.Execute(w, data)
```
---
## Cross-Site Scripting (XSS) — High
XSS allows attackers to execute malicious scripts.
**Bad:**
```go
w.Write([]byte(fmt.Sprintf("<div>%s</div>", data))) // DON'T
```
**Good:**
```go
import "html/template"
t := template.Must(template.New("safe").Parse("<div>{{.}}</div>"))
t.Execute(w, data) // Auto-escapes
```
---
## HTML Tag Injection — High
Injecting HTML tags through unvalidated input.
**Bad:**
```go
fmt.Fprintf(w, "<div>Welcome, %s!</div>", input) // DON'T
```
**Good:**
```go
import "html"
escaped := html.EscapeString(input)
fmt.Fprintf(w, "<div>Welcome, %s!</div>", escaped)
```
---
## Server-Side Request Forgery (SSRF) — High
Forcing the server to make requests to unintended endpoints.
**Bad:**
```go
url := r.URL.Query().Get("url")
resp, _ := http.Get(url) // DON'T: No validation
```
**Good:**
```go
u, err := url.Parse(targetURL)
// Block non-HTTP/S protocols
if u.Scheme != "http" && u.Scheme != "https" {
return errors.New("invalid scheme")
}
// Block internal hosts
if isInternalIP(u.Hostname()) {
return errors.New("internal host not allowed")
}
// Block metadata endpoints
if strings.Contains(u.Hostname(), "metadata.") {
return errors.New("metadata endpoint blocked")
}
```
---
## Unsafe Deserialization — Critical
Deserializing untrusted input can lead to resource exhaustion, type confusion, or unsafe object construction.
**Bad:**
```go
dec := gob.NewDecoder(r.Body) // DON'T: gob is not hardened for adversarial input
var user interface{}
dec.Decode(&user)
```
**Good:**
```go
import "encoding/json"
dec := json.NewDecoder(r.Body)
var user User
dec.Decode(&user) // JSON doesn't execute code
// Validate fields
```
---
## CWE References
- **CWE-78**: OS Command Injection
- **CWE-89**: SQL Injection
- **CWE-94**: Code Injection
- **CWE-79**: Cross-site Scripting (XSS)
- **CWE-918**: Server-Side Request Forgery (SSRF)
- **CWE-502**: Deserialization of Untrusted Data
- **CWE-20**: Improper Input Validation
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |