Golang Security

Persona: You are a senior Go security engineer. You apply security thinking both when auditing existing code and when writing new code — threats are easier to prevent than to fix.

Thinking mode: Use ultrathink for security audits and vulnerability analysis. Security bugs hide in subtle interactions — deep reasoning catches what surface-level review misses.

Modes:

• Review mode — reviewing a PR for security issues. Start from the changed files, then trace call sites and data flows into adjacent code — a vulnerability may live outside the diff but be triggered by it. Sequential.
• Audit mode — full codebase security scan. Launch up to 5 parallel sub-agents (via the Agent tool), each covering an independent vulnerability domain: (1) injection patterns, (2) cryptography and secrets, (3) web security and headers, (4) authentication and authorization, (5) concurrency safety and dependency vulnerabilities. Aggregate findings, score with DREAD, and report by severity.
• Coding mode — use when writing new code or fixing a reported vulnerability. Follow the skill's sequential guidance. Optionally launch a background agent to grep for common vulnerability patterns in newly written code while the main agent continues implementing the feature.

Dependencies:

• govulncheck: go install golang.org/x/vuln/cmd/govulncheck@latest

Go Security

Overview

Security in Go follows the principle of defense in depth: protect at multiple layers, validate all inputs, use secure defaults, and leverage the standard library's security-aware design. Go's type system and concurrency model provide some inherent protections, but vigilance is still required.

Security Thinking Model

Before writing or reviewing code, ask three questions:

1. What are the trust boundaries? — Where does untrusted data enter the system? (HTTP requests, file uploads, environment variables, database rows written by other services) 2. What can an attacker control? — Which inputs flow into sensitive operations? (SQL queries, shell commands, HTML output, file paths, cryptographic operations) 3. What is the blast radius? — If this defense fails, what's the worst outcome? (Data leak, RCE, privilege escalation, denial of service)

Severity Levels

Levels align with DREAD scoring.

Research Before Reporting

Before flagging a security issue, trace the full data flow through the codebase — don't assess a code snippet in isolation.

1. Trace the data origin — follow the variable back to where it enters the system. Is it user input, a hardcoded constant, or an internal-only value? 2. Check for upstream validation — look for input validation, sanitization, type parsing, or allow-listing earlier in the call chain. 3. Examine the trust boundary — if the data never crosses a trust boundary (e.g., internal service-to-service with mTLS), the risk profile is different. 4. Read the surrounding code, not just the diff — middleware, interceptors, or wrapper functions may already provide a layer of defense.

Severity adjustment, not dismissal: upstream protection does not eliminate a finding — defense in depth means every layer should protect itself. But it changes severity: a SQL concatenation reachable only through a strict input parser is medium, not critical. Always report the finding with adjusted severity and note which upstream defenses exist and what would happen if they were removed or bypassed.

When downgrading or skipping a finding: add a brief inline comment (e.g., // security: SQL concat safe here — input is validated by parseUserID() which returns int) so the decision is documented, reviewable, and won't be re-flagged by future audits.

Threat Modeling (STRIDE)

Apply STRIDE to every trust boundary crossing and data flow in your system: Spoofing (authentication), Tampering (integrity), Repudiation (audit logging), Information Disclosure (encryption), Denial of Service (rate limiting), Elevation of Privilege (authorization). Score each threat using DREAD (Damage, Reproducibility, Exploitability, Affected users, Discoverability) to prioritize remediation — Critical (8-10) demands immediate action.

For the full methodology with Go examples, DFD trust boundaries, DREAD scoring, and OWASP Top 10 mapping, see [Threat Modeling Guide](./references/threat-modeling.md).

Quick Reference

Detailed Categories

For complete examples, code snippets, and CWE mappings, see:

• [Cryptography](./references/cryptography.md) — Algorithms, key derivation, TLS configuration.
• [Injection Vulnerabilities](./references/injection.md) — SQL, command, template injection, XSS, SSRF.
• [Filesystem Security](./references/filesystem.md) — Path traversal, zip bombs, file permissions, symlinks.
• [Network/Web Security](./references/network.md) — SSRF, open redirects, HTTP headers, timing attacks, session fixation.
• [Cookie Security](./references/cookies.md) — Secure, HttpOnly, SameSite flags.
• [Third-Party Data Leaks](./references/third-party.md) — Analytics privacy risks, GDPR/CCPA compliance.
• [Memory Safety](./references/memory-safety.md) — Integer overflow, memory aliasing, unsafe usage.
• [Secrets Management](./references/secrets.md) — Hardcoded credentials, env vars, secret managers.
• [Logging Security](./references/logging.md) — PII in logs, log injection, sanitization.
• [Threat Modeling Guide](./references/threat-modeling.md) — STRIDE, DREAD scoring, trust boundaries, OWASP Top 10.
• [Security Architecture](./references/architecture.md) — Defense-in-depth, Zero Trust, auth patterns, rate limiting, anti-patterns.

Code Review Checklist

For the full security review checklist organized by domain (input handling, database, crypto, web, auth, errors, dependencies, concurrency), see [Security Review Checklist](./references/checklist.md) — a comprehensive checklist for code review with coverage of all major vulnerability categories.

Tooling & Verification

Static Analysis & Linting

Security-relevant linters: bodyclose, sqlclosecheck, nilerr, errcheck, govet, staticcheck. See the samber/cc-skills-golang@golang-lint skill for configuration and usage.

For deeper security-specific analysis:

# Go security checker (SAST)
go get -tool github.com/securego/gosec/v2/cmd/gosec@latest
go tool gosec ./...

# Vulnerability scanner — see golang-dependency-management for full govulncheck usage
go get -tool golang.org/x/vuln/cmd/govulncheck@latest
go tool govulncheck ./...

To check the known CVEs of a specific module or version without scanning the whole tree (e.g. when vetting a dependency on pkg.go.dev), → See samber/cc-skills-golang@golang-pkg-go-dev skill.

Security Testing

# Race detector
go test -race ./...

# Fuzz testing
go test -fuzz=Fuzz

Common Mistakes

Security Anti-Patterns

See [Security Architecture](./references/architecture.md) for detailed anti-patterns with Go code examples.

Cross-References

See samber/cc-skills-golang@golang-database, samber/cc-skills-golang@golang-safety, samber/cc-skills-golang@golang-observability, samber/cc-skills-golang@golang-continuous-integration skills.

• → See samber/cc-skills-golang@golang-continuous-integration skill for automated AI-driven code review in CI using these guidelines

Additional Resources

• Go Security Best Practices
• gosec Security Linter
• govulncheck
• OWASP Go Secure Coding Practices

Security Architecture Patterns

Defense-in-depth, Zero Trust, and authentication patterns for Go services.

Defense-in-Depth Layers

Multiple security controls ensure that failure of one layer doesn't compromise the system:

Layer 1: PERIMETER — Rate limiting, DDoS mitigation, WAF
Layer 2: NETWORK  — TLS/mTLS, network segmentation
Layer 3: APPLICATION — Input validation, auth, authz, secure coding
Layer 4: DATA     — Encryption at rest/transit, access controls, backups

Go Implementation by Layer

Layer 1 — Rate Limiting Middleware:

import "golang.org/x/time/rate"

// Global rate limiter
func RateLimitMiddleware(rps float64, burst int) func(http.Handler) http.Handler {
    limiter := rate.NewLimiter(rate.Limit(rps), burst)
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            if !limiter.Allow() {
                http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
                return
            }
            next.ServeHTTP(w, r)
        })
    }
}

Per-client rate limiting prevents a single abuser from exhausting the global limit:

type ClientRateLimiter struct {
    mu      sync.Mutex
    clients map[string]*rate.Limiter
    rps     rate.Limit
    burst   int
}

func (crl *ClientRateLimiter) GetLimiter(clientIP string) *rate.Limiter {
    crl.mu.Lock()
    defer crl.mu.Unlock()
    if limiter, exists := crl.clients[clientIP]; exists {
        return limiter
    }
    limiter := rate.NewLimiter(crl.rps, crl.burst)
    crl.clients[clientIP] = limiter
    return limiter
}

Layer 2 — mTLS for Service-to-Service:

func mTLSConfig(caCertFile, clientCertFile, clientKeyFile string) (*tls.Config, error) {
    caCertPool := x509.NewCertPool()
    caCert, err := os.ReadFile(caCertFile)
    if err != nil { return nil, err }
    caCertPool.AppendCertsFromPEM(caCert)

    cert, err := tls.LoadX509KeyPair(clientCertFile, clientKeyFile)
    if err != nil { return nil, err }

    return &tls.Config{
        Certificates: []tls.Certificate{cert},
        RootCAs:      caCertPool,
        MinVersion:   tls.VersionTLS12,
    }, nil
}

Layer 3 — Request Body Size Limiting:

func MaxBodySize(maxBytes int64) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            r.Body = http.MaxBytesReader(w, r.Body, maxBytes)
            next.ServeHTTP(w, r)
        })
    }
}

Layer 4 — Encryption at Rest (AES-GCM):

Use crypto/aes with GCM mode for authenticated encryption. See Cryptography Security for full EncryptAESGCM/DecryptAESGCM implementations, algorithm selection guide, and envelope encryption for key rotation.

---

Zero Trust Principles

// Zero Trust middleware: verify identity + permissions on every request
func ZeroTrustMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 1. Verify token
        claims, err := validateJWT(r.Header.Get("Authorization"))
        if err != nil {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        // 2. Verify permissions for this specific resource
        if !hasPermission(claims.Subject, r.Method, r.URL.Path) {
            http.Error(w, "Forbidden", http.StatusForbidden)
            return
        }
        // 3. Audit log
        logger.Info("access_granted",
            "user", claims.Subject,
            "method", r.Method,
            "path", r.URL.Path,
            "ip", r.RemoteAddr,
        )
        ctx := context.WithValue(r.Context(), userClaimsKey, claims)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

---

Authentication Pattern Selection

JWT Validation — Complete Example

JWT validation must pin the signing algorithm to prevent algorithm confusion attacks (where an attacker switches RS256 to HS256 and signs with the public key):

import "github.com/golang-jwt/jwt/v5"

func validateJWT(authHeader string) (*jwt.RegisteredClaims, error) {
    tokenString := strings.TrimPrefix(authHeader, "Bearer ")
    token, err := jwt.ParseWithClaims(tokenString, &jwt.RegisteredClaims{},
        func(token *jwt.Token) (interface{}, error) {
            // Pin signing algorithm — prevents algorithm confusion
            if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
                return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
            }
            return publicKey, nil
        },
        jwt.WithIssuer("your-issuer"),
        jwt.WithAudience("your-audience"),
        jwt.WithExpirationRequired(),
    )
    if err != nil { return nil, err }
    claims, ok := token.Claims.(*jwt.RegisteredClaims)
    if !ok { return nil, errors.New("invalid claims") }
    return claims, nil
}

Password Hashing — Argon2id

Argon2id is the recommended password hashing algorithm (memory-hard, resists GPU attacks). For algorithm comparison (bcrypt, scrypt, PBKDF2), see Cryptography Security.

import "golang.org/x/crypto/argon2"

type PasswordConfig struct {
    Time    uint32 // iterations
    Memory  uint32 // KB
    Threads uint8
    KeyLen  uint32
    SaltLen uint32
}

// OWASP recommended parameters
var DefaultConfig = PasswordConfig{
    Time: 3, Memory: 64 * 1024, Threads: 4, KeyLen: 32, SaltLen: 16,
}

func HashPassword(password string, cfg PasswordConfig) (string, error) {
    salt := make([]byte, cfg.SaltLen)
    if _, err := rand.Read(salt); err != nil { return "", err }
    hash := argon2.IDKey([]byte(password), salt, cfg.Time, cfg.Memory, cfg.Threads, cfg.KeyLen)
    // Encode salt + hash for storage
    return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
        argon2.Version, cfg.Memory, cfg.Time, cfg.Threads,
        base64.RawStdEncoding.EncodeToString(salt),
        base64.RawStdEncoding.EncodeToString(hash),
    ), nil
}

---

HTTP Security Headers

Set on every response via middleware:

func SecurityHeadersMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Security-Policy", "default-src 'self'; script-src 'self'")
        w.Header().Set("X-Frame-Options", "DENY")
        w.Header().Set("X-Content-Type-Options", "nosniff")
        w.Header().Set("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
        w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin")
        w.Header().Set("Permissions-Policy", "geolocation=(), microphone=(), camera=()")
        next.ServeHTTP(w, r)
    })
}

---

Security Anti-Patterns

// Anti-pattern: trusting client-provided identity
func badHandler(w http.ResponseWriter, r *http.Request) {
    if r.Header.Get("X-Is-Admin") == "true" { // attacker sets this header
        adminPanel(w, r)
    }
}

// Correct: server-side identity verification
func goodHandler(w http.ResponseWriter, r *http.Request) {
    claims := r.Context().Value(userClaimsKey).(*jwt.RegisteredClaims)
    if !hasRole(claims.Subject, "admin") {
        http.Error(w, "Forbidden", http.StatusForbidden)
        return
    }
    adminPanel(w, r)
}

Security Review Checklist

Severity: Critical, High, Medium, Low

Input Handling

• [ ] High All user input validated at system boundaries — internal code trusts the boundary
• [ ] High Input uses allowlists, not blocklists — blocklists always miss something
• [ ] High Sanitized on output (HTML, SQL, shell) — context-dependent escaping
• [ ] Medium Length limits enforced — prevents buffer abuse and DoS

Database

• [ ] Critical SQL queries use parameterized placeholders — keeps data and code separate
• [ ] Critical ORM/library protects against SQL injection
• [ ] Critical No direct SQL construction with user input

Code Execution

• [ ] Critical No exec.Command() with shell arguments — metacharacters enable injection
• [ ] Critical No eval, reflection on untrusted input — arbitrary code execution risk
• [ ] Critical No deserialization of untrusted data — can trigger arbitrary constructors

Cryptography

• [ ] High Uses crypto/rand for security-critical randomness — math/rand is predictable
• [ ] High Uses vetted algorithms (AES-GCM, Argon2id, bcrypt) — custom crypto hasn't been analyzed
• [ ] Critical Proper key management — hardcoded secrets leak through VCS, logs, and backups
• [ ] Medium HMAC for message authentication — prevents tampering

Web Security

• [ ] High TLS 1.2+ configured correctly — older versions have known attacks
• [ ] Medium Security headers set (HSTS, CSP, X-Frame-Options) — prevents framing, sniffing, downgrade
• [ ] Medium CSRF protection for state-changing requests — prevents cross-origin action forgery
• [ ] Medium Open redirects validated — attackers use your domain to redirect to phishing
• [ ] High XSS protected via html/template auto-escaping

Authentication/Authorization

• [ ] High Passwords hashed with Argon2id (preferred) or bcrypt — intentionally slow to resist brute-force
• [ ] High Sessions use secure tokens from crypto/rand
• [ ] High Authorization checked on every privileged action — not just at login
• [ ] High JWT tokens validated (algorithm, claims, expiry) — unsigned JWTs bypass auth
• [ ] High Expired/invalid sessions invalidated server-side

Error Handling

• [ ] Medium Generic error messages to users — detailed errors help attackers map your system
• [ ] Medium Detailed errors logged server-side only
• [ ] Medium Stack traces not leaked to clients
• [ ] Medium Database errors not exposed — reveals schema and query structure

Dependency Security

• [ ] High govulncheck passes — catches known CVEs in your dependency tree
• [ ] High Dependencies updated regularly — unpatched deps are the #1 attack vector
• [ ] Medium Third-party libraries reviewed for security posture

HTTP Security Headers

• [ ] Medium Content-Security-Policy set — restricts resource sources to prevent XSS
• [ ] Medium X-Frame-Options: DENY — prevents clickjacking via iframe embedding
• [ ] Medium X-Content-Type-Options: nosniff — prevents MIME-type sniffing attacks
• [ ] Medium Strict-Transport-Security with includeSubDomains — forces HTTPS, prevents downgrade
• [ ] Low Referrer-Policy set — controls referrer header leakage to external sites
• [ ] Low Permissions-Policy set — restricts browser features (camera, mic, geolocation)

Rate Limiting & DoS Prevention

• [ ] Medium HTTP server has ReadTimeout, WriteTimeout, IdleTimeout — prevents Slowloris
• [ ] Medium Request body size limited with http.MaxBytesReader — prevents memory exhaustion
• [ ] Medium Rate limiting on authentication endpoints — prevents brute-force and credential stuffing
• [ ] Medium Rate limiting on expensive operations (search, export, file upload)

Concurrency

• [ ] High -race detector passes — races cause data corruption and can bypass auth checks
• [ ] High Shared state properly synchronized
• [ ] High No data races on global variables

Cookie Security Rules

Cookie security is critical for preventing session hijacking and XSS exploitation.

Rules:

1. Cookies MUST set HttpOnly for session and authentication cookies. 2. Cookies MUST set Secure in production (HTTPS only). 3. SameSite SHOULD be Lax or Strict — use None only when cross-site access is required.

---

HTTP-Only Flag Missing — Medium

Without HttpOnly flag, cookies can be accessed via JavaScript.

Bad:

cookie := &http.Cookie{
    Name:  "session",
    Value: sessionID,
    // DON'T: Missing HttpOnly, Secure flags
}

Good:

cookie := &http.Cookie{
    Name:     "session",
    Value:    sessionID,
    HttpOnly: true,   // Prevents JavaScript access
    Secure:   true,   // Only sends over HTTPS
    SameSite: http.SameSiteStrictMode,
    Path:     "/",
    MaxAge:   3600,
}

---

Insecure Cookie Configuration (Missing Secure Flag) — Medium

Without Secure flag, cookies are sent over unencrypted HTTP.

Bad:

http.SetCookie(w, &http.Cookie{
    Name:  "auth_token",
    Value: token,
    // Missing Secure, HttpOnly flags
})

Good:

http.SetCookie(w, &http.Cookie{
    Name:     "auth_token",
    Value:    token,
    Secure:   true,   // HTTPS only
    HttpOnly: true,   // No JavaScript access
    SameSite: http.SameSiteLaxMode,
    Path:     "/",
    MaxAge:   86400,
    Domain:   "",  // Default: send to exact host only
})

---

SameSite Cookie Protection — Medium

SameSite attribute protects against CSRF attacks.

Bad:

cookie := &http.Cookie{
    Name:     "session",
    Value:    token,
    Secure:   true,
    HttpOnly: true,
    // DON'T: Missing SameSite
}

Good:

// Strict for high-security operations
authCookie := &http.Cookie{
    Name:     "auth",
    Value:    token,
    Secure:   true,
    HttpOnly: true,
    SameSite: http.SameSiteStrictMode,
}

// Lax for most applications
sessionCookie := &http.Cookie{
    Name:     "session",
    Value:    token,
    Secure:   true,
    HttpOnly: true,
    SameSite: http.SameSiteLaxMode,
}

// None for cross-site cookies (requires Secure: true)
crossSiteCookie := &http.Cookie{
    Name:     "analytics",
    Value:    trackingID,
    Secure:   true,
    HttpOnly: true,
    SameSite: http.SameSiteNoneMode,
}

---

Cookie Prefix Examples — Low

Modern cookie prefixes enforce cookie behavior in browsers.

// __Secure- prefix: Requires Secure flag
secureCookie := &http.Cookie{
    Name:     "__Secure-Session",
    Value:    token,
    Secure:   true,   // Required for __Secure-
    HttpOnly: true,
}

// __Host- prefix: Requires Secure, no Domain, origin-bound path
hostCookie := &http.Cookie{
    Name:     "__Host-CSRF",
    Value:    csrfToken,
    Secure:   true,    // Required
    HttpOnly: true,
    Domain:   "",      // Must be empty
    Path:     "/",     // Required
}

---

Gorilla Sessions Cookie Security — High

Bad:

import "github.com/gorilla/sessions"
store := sessions.NewCookieStore([]byte("secret-key")) // DON'T: Hardcoded key

Good:

import "github.com/gorilla/sessions"

store := sessions.NewCookieStore(
    []byte(os.Getenv("SESSION_AUTH_KEY")),   // Use env var
    []byte(os.Getenv("SESSION_ENC_KEY")),   // Separate encryption key
)

store.Options = &sessions.Options{
    Path:     "/",
    MaxAge:   86400 * 30,
    HttpOnly: true,
    Secure:   true,
    SameSite: http.SameSiteStrictMode,
}

---

Cookie Best Practices Checklist

• [ ] Set HttpOnly: true for all authentication cookies
• [ ] Set Secure: true for all cookies over HTTPS
• [ ] Set appropriate SameSite value (Strict/Lax/None)
• [ ] Use short MaxAge expiration
• [ ] Avoid setting cookie Domain unless necessary
• [ ] Validate cookie values on every request
• [ ] Use cryptographically signed cookies
• [ ] Rotate cookie secrets regularly
• [ ] Clear cookies on logout
• [ ] Use double-submit cookie pattern for CSRF protection

---

CWE References

• CWE-1004: Sensitive Cookie Without 'HttpOnly' Flag
• CWE-614: Sensitive Cookie in HTTPS Session Without 'Secure' Attribute
• CWE-352: Cross-Site Request Forgery (CSRF)
• CWE-285: Improper Authorization
• CWE-565: Reliance on Cookies without Validation

Cryptography Security Rules

Cryptography vulnerabilities threaten confidentiality and integrity of sensitive data.

Rules:

1. TLS MUST use 1.2+. 2. NEVER use DES, RC4, MD5, or SHA1 for security purposes. 3. SSH host keys MUST be verified — NEVER use InsecureIgnoreHostKey. 4. Passwords MUST be hashed with Argon2id (preferred) or bcrypt. 5. Security-critical randomness MUST use crypto/rand.

---

Algorithm Selection Guide

Choose the right algorithm for the job — using the wrong primitive (e.g. SHA256 for passwords) is as dangerous as using a broken one:

Key Size Requirements

---

Key Rotation Pattern

Keys should be rotated periodically. Use envelope encryption so rotating the Key Encryption Key (KEK) doesn't require re-encrypting all data:

// Envelope encryption: encrypt data with a DEK, encrypt DEK with KEK
func EnvelopeEncrypt(kek, plaintext []byte) (encryptedDEK, ciphertext []byte, err error) {
    // 1. Generate random Data Encryption Key
    dek := make([]byte, 32)
    if _, err := rand.Read(dek); err != nil {
        return nil, nil, err
    }

    // 2. Encrypt data with DEK
    ciphertext, err = EncryptAESGCM(dek, plaintext)
    if err != nil {
        return nil, nil, err
    }

    // 3. Encrypt DEK with KEK
    encryptedDEK, err = EncryptAESGCM(kek, dek)
    if err != nil {
        return nil, nil, err
    }

    return encryptedDEK, ciphertext, nil
}

func EnvelopeDecrypt(kek, encryptedDEK, ciphertext []byte) ([]byte, error) {
    dek, err := DecryptAESGCM(kek, encryptedDEK)
    if err != nil {
        return nil, err
    }
    return DecryptAESGCM(dek, ciphertext)
}

func EncryptAESGCM(key, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil { return nil, err }
    aead, err := cipher.NewGCM(block)
    if err != nil { return nil, err }
    nonce := make([]byte, aead.NonceSize())
    if _, err := rand.Read(nonce); err != nil { return nil, err }
    return aead.Seal(nonce, nonce, plaintext, nil), nil
}

func DecryptAESGCM(key, ciphertext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil { return nil, err }
    aead, err := cipher.NewGCM(block)
    if err != nil { return nil, err }
    nonceSize := aead.NonceSize()
    if len(ciphertext) < nonceSize {
        return nil, errors.New("ciphertext too short")
    }
    return aead.Open(nil, ciphertext[:nonceSize], ciphertext[nonceSize:], nil)
}

When the KEK is rotated, only re-encrypt the DEKs (small), not the data (potentially large).

---

Common Cryptographic Mistakes

Mistake 1: AES-ECB reveals patterns — High

ECB encrypts each block independently — identical plaintext blocks produce identical ciphertext blocks, revealing data structure:

// Bad — ECB mode reveals patterns in structured data
block, _ := aes.NewCipher(key)
// Using block.Encrypt directly = ECB mode

// Good — GCM provides authenticated encryption
aead, err := cipher.NewGCM(block) // randomized, authenticated
if err != nil {
    return nil, err
}
nonce := make([]byte, aead.NonceSize())
if _, err := rand.Read(nonce); err != nil {
    return nil, err
}
ciphertext := aead.Seal(nonce, nonce, plaintext, nil)

Mistake 2: Reusing nonces — Critical

A nonce reuse with AES-GCM completely breaks confidentiality and authentication:

// Bad — static or reused nonce
nonce := []byte("fixed_nonce!") // catastrophic with GCM

// Good — random nonce per encryption
nonce := make([]byte, 12) // 96-bit for GCM
if _, err := rand.Read(nonce); err != nil {
    return nil, err
}

Mistake 3: Non-constant-time comparison for secrets — Medium

Comparing secrets with == short-circuits on the first differing byte, leaking timing information. See Network/Web Security — Observable Timing for constant-time comparison patterns using crypto/subtle.

---

Insecure TLS Configuration — High

Using insecure TLS configurations can expose your application to man-in-the-middle attacks.

Bad:

transport := &http.Transport{
    TLSClientConfig: &tls.Config{
        InsecureSkipVerify: true, // DON'T: verify certificates
    },
}

Good:

import "crypto/tls"

func secureConfig() *tls.Config {
    return &tls.Config{
        MinVersion:       tls.VersionTLS12,
        CurvePreferences: []tls.CurveID{tls.X25519, tls.CurveP256},
    }
}

---

DES Encryption — High

DES is cryptographically broken.

Bad:

import "crypto/des"
block, _ := des.NewCipher(key) // DON'T: broken

Good:

import "crypto/aes"
block, _ := aes.NewCipher(key)     // OK: AES
cipher.NewGCM(block)              // OK: GCM for auth

---

Insecure SSH Host Key Verification — High

Bad:

import "golang.org/x/crypto/ssh"
&ssh.ClientConfig{
    HostKeyCallback: ssh.InsecureIgnoreHostKey(), // DON'T
}

Good:

import "golang.org/x/crypto/ssh"
&ssh.ClientConfig{
    HostKeyCallback: ssh.FixedHostKey(publicKey),
}

---

MD5 Hash — High

MD5 is collision-prone and weak for security.

Bad:

import "crypto/md5"
hash := md5.Sum([]byte(data)) // DON'T: weak

Good:

// For password hashing:
import "golang.org/x/crypto/argon2"
hash := argon2.IDKey([]byte(pw), salt, 3, 64*1024, 4, 32)

// Or bcrypt (simpler API, no salt management):
import "golang.org/x/crypto/bcrypt"
hash, err := bcrypt.GenerateFromPassword([]byte(pw), bcrypt.DefaultCost)
if err != nil {
    return nil, err
}

// For general-purpose hashing (not passwords):
import "crypto/sha256"
digest := sha256.Sum256(data)

---

RC4 Cipher — High

RC4 is cryptographically broken.

Bad:

import "crypto/rc4"
cipher, _ := rc4.NewCipher(key) // DON'T: broken

Good:

import "crypto/cipher"
import "crypto/aes"
aead, _ := cipher.NewGCM(block) // OK: AES-GCM

// Or ChaCha20:
import "golang.org/x/crypto/chacha20poly1305"
aead, _ := chacha20poly1305.New(key)

---

SHA1 Hash — Medium

SHA1 provides insufficient collision resistance.

Bad:

import "crypto/sha1"
hash := sha1.Sum(data) // DON'T: weak

Good:

import "crypto/sha256"
hash := sha256.Sum256(data)

---

Weak Cryptographic Algorithms — Medium

Bad:

import "crypto/hmac"
import "crypto/md5"
mac := hmac.New(md5.New, key) // DON'T: HMAC-MD5

Good:

import "crypto/sha256"
mac := hmac.New(sha256.New, key)

---

Insufficient Key Strength — Medium

RSA keys smaller than 2048 bits are insufficient.

Bad:

import "crypto/rsa"
key, _ := rsa.GenerateKey(rand.Reader, 1024) // DON'T: too weak

Good:

key, _ := rsa.GenerateKey(rand.Reader, 4096) // OK: 2048+ bits

---

Weak Random Number Generators — High

math/rand is predictable, never use for security.

Bad:

import "math/rand"
bytes := make([]byte, 16)
rand.Read(bytes) // DON'T: predictable

Good:

import "crypto/rand"
_, err := rand.Read(bytes) // OK: cryptographically secure

---

Weak TLS Versions — High

TLS 1.0 and 1.1 have known vulnerabilities.

Bad:

import "crypto/tls"
&tls.Config{MinVersion: tls.VersionTLS10} // DON'T

Good:

&tls.Config{MinVersion: tls.VersionTLS12} // OK

---

Password Hashing — High

Don't use MD5, SHA1, or single-iteration hashes for passwords.

Bad:

import "crypto/sha256"
hash := sha256.Sum256([]byte(password)) // DON'T: too fast

Good:

// Argon2id (preferred) — memory-hard, resists GPU attacks:
import "golang.org/x/crypto/argon2"
key := argon2.IDKey([]byte(password), salt, 3, 64*1024, 4, 32)

// Or bcrypt (simpler API, widely supported):
import "golang.org/x/crypto/bcrypt"
hash, err := bcrypt.GenerateFromPassword([]byte(pw), bcrypt.DefaultCost)
if err != nil {
    return nil, err
}

// Or PBKDF2 with 600,000+ iterations (Go 1.24+ stdlib):
import "crypto/pbkdf2"
key, err := pbkdf2.Key(sha512.New, password, salt, 600_000, 32)
if err != nil {
    return err
}

// Or scrypt:
import "golang.org/x/crypto/scrypt"
key, err := scrypt.Key([]byte(password), salt, 32768, 8, 1, 32)
if err != nil {
    return err
}

For Go 1.24+, prefer stdlib crypto/hkdf, crypto/pbkdf2, and crypto/sha3. Use golang.org/x/crypto/... fallbacks only for modules targeting older Go versions or for algorithms still outside the standard library.

---

CWE References

• CWE-327: Use of a Broken or Risky Cryptographic Algorithm
• CWE-331: Insufficient Entropy
• CWE-326: Inadequate Encryption Strength
• CWE-295: Improper Certificate Validation
• CWE-330: Use of Insufficiently Random Values
• CWE-916: Use of Password Hash With Insufficient Computational Effort

Filesystem Security Rules

Filesystem vulnerabilities can lead to unauthorized file access, data leakage, and denial-of-service attacks.

Rules:

1. User-controlled file paths MUST be confined to an allowed root. 2. os.Root SHOULD be used for scoped file access (Go 1.24+). 3. Zip extraction MUST check for ZipSlip path traversal. 4. Temporary files MUST use os.CreateTemp — NEVER predictable names. 5. File permissions MUST be restrictive (0600 for secrets, 0750 for directories).

---

Directory Traversal — High

Paths like ../../etc/passwd access files outside intended directory.

Bad:

filepath := filepath.Join("/var/www", filename) // DON'T
http.ServeFile(w, r, filepath)

Good (Go 1.24+) — use `os.Root` for safe, scoped directory access:

root, err := os.OpenRoot("/var/www")
if err != nil { return err }
defer root.Close()
f, err := root.Open(filename) // cannot escape root directory

os.Root prevents ordinary path traversal at the OS level. All operations (Open, Create, Stat, OpenFile, etc.) are confined to the root directory, and symlinks that resolve outside the root are rejected. It is not a full sandbox: it does not by itself block bind mounts, special device files, or all /proc-style filesystem behavior. For archive extraction and uploads, still reject special files and choose a root without attacker-controlled mounts.

Good (pre-Go 1.24 fallback):

func safeJoin(baseDir, userPath string) (string, error) {
    if userPath == "" || filepath.IsAbs(userPath) || !filepath.IsLocal(userPath) {
        return "", errors.New("invalid relative path")
    }

    full := filepath.Join(baseDir, userPath)

    rel, err := filepath.Rel(baseDir, full)
    if err != nil {
        return "", fmt.Errorf("checking path: %w", err)
    }
    if rel == ".." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) {
        return "", errors.New("path escapes base directory")
    }

    return full, nil
}

This lexical fallback is not a full symlink-resistant substitute for os.Root.

Bad:

fullPath := filepath.Join(baseDir, filename)
if !strings.HasPrefix(filepath.Clean(fullPath), filepath.Clean(baseDir)) {
    return errors.New("access denied")
}

---

Zip Archive Path Traversal — High

Malicious zip files can escape extraction directory.

Bad:

for _, file := range reader.File {
    path := filepath.Join(dest, file.Name) // DON'T: No validation
    file.Create(path)
}

Good (Go 1.24+) — use `os.Root` to scope extraction:

root, err := os.OpenRoot(dest)
if err != nil { return err }
defer root.Close()
for _, file := range reader.File {
    f, err := root.OpenFile(file.Name, os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil { return err } // rejects paths escaping root
    // ... copy contents ...
    f.Close()
}

Good (pre-Go 1.24 fallback):

for _, file := range reader.File {
    if !filepath.IsLocal(file.Name) {
        return fmt.Errorf("unsafe archive path: %q", file.Name)
    }

    targetPath, err := safeJoin(dest, file.Name)
    if err != nil {
        return err
    }

    // create parent directories, then write targetPath
    _ = targetPath
}

---

Decompression Bomb — Medium

Tiny compressed files can expand to GBs.

Bad:

gr, _ := gzip.NewReader(f)
out, _ := os.Create(dst)
io.Copy(out, gr) // DON'T: No size limits

Good:

const maxDecompressedSize = 100 * 1024 * 1024 // 100MB limit

var errDecompressedSizeLimitExceeded = errors.New("decompressed size limit exceeded")

type limitedReader struct {
    r    io.Reader
    read int64
}

func (l *limitedReader) Read(p []byte) (int, error) {
    if l.read >= maxDecompressedSize {
        // Return a sentinel error — io.EOF would be treated as success by io.Copy
        return 0, errDecompressedSizeLimitExceeded
    }
    n, err := l.r.Read(p)
    l.read += int64(n)
    return n, err
}

lr := &limitedReader{r: gr}
if _, err := io.Copy(out, lr); err != nil {
    return fmt.Errorf("decompressing: %w", err)
}

---

Insecure Temporary File Creation — Medium

Creating temp files without proper permissions.

Bad:

f, _ := os.Create("/tmp/myapp.temp") // DON'T: Predictable name
f.WriteString(data)

Good:

f, err := os.CreateTemp("", "myapp.*")
defer os.Remove(f.Name())
f.Chmod(0600) // Restrictive permissions

---

Insecure File Permissions — Medium

Opening files with excessive permissions.

Bad:

f, _ := os.OpenFile("config.json", os.O_CREATE, 0644) // DON'T: World-readable

Good:

f, _ := os.OpenFile("config.json", os.O_CREATE, 0600) // OK: Owner only

---

Insecure mkdir — Low

Creating directories with overly permissive permissions.

Bad:

os.MkdirAll("/var/myapp/cache", 0777) // DON'T: World-writable

Good:

os.MkdirAll("/var/myapp/cache", 0750) // OK: Group-writable

---

Insecure File Write Permissions — Medium

Opening files for writing with inappropriate permissions.

Bad:

os.OpenFile("app.log", os.O_CREATE, 0666) // DON'T: World-writable

Good:

os.OpenFile("app.log", os.O_CREATE|os.O_APPEND, 0640) // OK

---

Tainted File Read — High

Reading files based on unvalidated input.

Bad:

func readFile(filename string) ([]byte, error) {
    return os.ReadFile(filename) // DON'T: No validation
}

Good (Go 1.24+):

const allowedDir = "/var/www/public/"

func readFile(filename string) ([]byte, error) {
    root, err := os.OpenRoot(allowedDir)
    if err != nil { return nil, err }
    defer root.Close()
    f, err := root.Open(filename) // cannot escape root directory
    if err != nil { return nil, err }
    defer f.Close()
    return io.ReadAll(f)
}

Good (pre-Go 1.24 fallback):

const allowedDir = "/var/www/public/"

func readFile(filename string) ([]byte, error) {
    fullPath, err := safeJoin(allowedDir, filename)
    if err != nil {
        return nil, err
    }
    return os.ReadFile(fullPath)
}

---

CWE References

• CWE-22: Path Traversal (Directory Traversal)
• CWE-409: Zip Bomb Decompression
• CWE-379: Insecure Temp File Creation
• CWE-732: Incorrect File Permissions

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.

---

SQL Injection — Critical

Building SQL queries by concatenating user input. Always use prepared statements with placeholders.

Bad:

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:

// 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:

query := fmt.Sprintf("SELECT * FROM users WHERE id IN (%s)", strings.Join(ids, ","))

Good:

// 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:

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:

query := fmt.Sprintf("SELECT * FROM users ORDER BY %s", sortCol) // SQL injection

Good:

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.

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:

xpathQuery := "//user[@username='" + username + "']" // Vulnerable

Good:

// 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:

template := "func handle" + resourceName + "() {...}" // DON'T

Good:

// 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:

cmd := exec.Command("sh", "-c", "rm -f /tmp/"+filename) // DON'T

Good:

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:

data := r.URL.Query().Get("user") // Untrusted input
t.Execute(w, data)

Good:

// 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:

w.Write([]byte(fmt.Sprintf("<div>%s</div>", data))) // DON'T

Good:

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:

fmt.Fprintf(w, "<div>Welcome, %s!</div>", input) // DON'T

Good:

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:

url := r.URL.Query().Get("url")
resp, _ := http.Get(url) // DON'T: No validation

Good:

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:

dec := gob.NewDecoder(r.Body) // DON'T: gob is not hardened for adversarial input
var user interface{}
dec.Decode(&user)

Good:

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

Logging Security Rules

Logging sensitive information can lead to data exposure and compliance violations.

Rules:

1. PII MUST NEVER be logged — filter passwords, tokens, emails, and personal data. 2. Log injection MUST be prevented — sanitize user input before logging. 3. Error messages MUST NOT expose internals to users — log details server-side, return generic messages.

---

Sensitive Data in Logs — Medium

Bad:

type User struct {
    ID       string
    Username string
    Password string
    Token    string
}

func logUserLogin(user *User) {
    log.Printf("User logged in: %+v\n", user)  // DON'T: Logs password, token
}

Good:

import "log/slog"

func logUserLogin(logger *slog.Logger, user *User) {
    logger.Info("user_login",
        "user_id", user.ID,
        "username", user.Username,
        // Don't log: password, token
    )
}

---

Log Injection — Low

User input in logs can lead to log injection attacks.

Bad:

log.Printf("User logged in: %s\n", username)  // DON'T: No sanitization

Good:

import "log/slog"

// Sanitize user input before logging
func sanitizeLogInput(input string) string {
    // Remove control characters
    var result strings.Builder
    for _, r := range input {
        if !unicode.IsControl(r) || r == '\n' || r == '\t' {
            result.WriteRune(r)
        }
    }
    return result.String()
}

func logUsername(logger *slog.Logger, username string) {
    sanitized := sanitizeLogInput(username)
    logger.Info("user_login", "username", sanitized)
}

---

Information Leakage in Error Messages — Medium

Bad:

func handleDatabaseError(err error) error {
    return fmt.Errorf("database error: %v", err)  // DON'T: Leaks internal details
}

func dbErrorToHTTP(err error) {
    http.Error(w, "Error: "+err.Error(), 500)  // DON'T
}

Good:

func handleDatabaseError(logger *slog.Logger, err error) error {
    // Log detailed error for debugging
    logger.Error("database_error", "error", err.Error())
    // Return generic message to client
    return errors.New("database operation failed")
}

func dbErrorToHTTP(w http.ResponseWriter, logger *slog.Logger, err error) {
    logger.Error("database_error", "error", err.Error())
    http.Error(w, "Internal server error", http.StatusInternalServerError)
}

---

General Logger Security — Low

Bad:

import "log"
log.Println("User logged in:", user.ID, password)  // DON'T: Logs password
fmt.Printf("DEBUG: %+v\n", data)  // DON'T: Raw data

Good:

import "log/slog"

handler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level:     slog.LevelInfo,
    AddSource: false,
})
logger := slog.New(handler)

logger.Info("user_login",
    "user_id", userID,
    "ip_address", request.RemoteIP,
)

---

Log Security Checklist

• [ ] No passwords, tokens, or secrets in logs
• [ ] No PII/PHI in production logs
• [ ] Sanitize user input before logging
• [ ] Use structured logging (JSON)
• [ ] Implement log level strategy
• [ ] Separate access logs from error logs
• [ ] Log file permissions restricted (e.g., 600)
• [ ] Log rotation prevents disk exhaustion
• [ ] Generic error messages to clients
• [ ] Detailed errors only in internal logs

---

CWE References

• CWE-532: Insertion of Sensitive Information into Log File
• CWE-117: Improper Output Neutralization for Logs
• CWE-209: Information Exposure Through an Error Message
• CWE-200: Exposure of Sensitive Information
• CWE-312: Cleartext Storage of Sensitive Information

Memory Safety Security Rules

Memory safety vulnerabilities can lead to crashes, data corruption, and security compromises.

Rules:

1. Integer overflow MUST be checked at boundaries — NEVER trust unchecked arithmetic on external input. 2. unsafe MUST NOT be used in application code — restrict to low-level libraries with thorough review. 3. Data races MUST be detected with -race flag in CI.

---

Integer Overflow — High

Integer overflows can cause unexpected behavior and crashes.

Bad:

func allocateBuffer(rows, cols int) []byte {
    size := rows * cols  // DON'T: Can overflow
    return make([]byte, size)
}

Good:

import "math"

func safeMultiply(a, b int) (int, error) {
    if a == 0 || b == 0 {
        return 0, nil
    }
    if a > math.MaxInt/b {
        return 0, errors.New("integer overflow")
    }
    result := a * b
    if result/b != a {
        return 0, errors.New("overflow detected")
    }
    return result, nil
}

func allocateBuffer(rows, cols int) ([]byte, error) {
    size, err := safeMultiply(rows, cols)
    if err != nil {
        return nil, err
    }
    const maxBufferSize = 100 * 1024 * 1024 // 100MB limit
    if size > maxBufferSize {
        return nil, errors.New("buffer size exceeds limit")
    }
    return make([]byte, size), nil
}

---

math/big.Rat Issues — Low

Rat can consume large amounts of memory if denominators grow without bounds.

Bad:

import "math/big"

func unsafeFraction(operations int) *big.Rat {
    r := big.NewRat(1, 1)
    for i := 0; i < operations; i++ {
        r.Mul(r, big.NewRat(int64(i+1), int64(i+2)))  // DON'T
    }
    return r  // Could be memory intensive
}

Good:

const maxRatNumBits = 1000

func safeFraction(operations int) (*big.Rat, error) {
    r := big.NewRat(1, 1)
    for i := 0; i < operations; i++ {
        r.Mul(r, big.NewRat(int64(i+1), int64(i+2)))
        if r.Num().BitLen() > maxRatNumBits || r.Denom().BitLen() > maxRatNumBits {
            return nil, errors.New("fraction precision too large")
        }
    }
    return r, nil
}

---

Memory Aliasing Vulnerability — Medium

Memory aliasing can cause data corruption and race conditions.

Bad:

func reverseBytes(data []byte) {
    for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 {
        data[i], data[j] = data[j], data[i]  // DON'T if slices alias
    }
}

Good:

import "unsafe"

func checkOverlap(a, b []byte) bool {
    if len(a) == 0 || len(b) == 0 {
        return false
    }
    aStart := uintptr(unsafe.Pointer(&a[0]))
    aEnd := aStart + uintptr(len(a))
    bStart := uintptr(unsafe.Pointer(&b[0]))
    bEnd := bStart + uintptr(len(b))
    return aStart < bEnd && bStart < aEnd
}

func safeCopy(dest, src []byte) {
    if checkOverlap(dest, src) {
        temp := make([]byte, len(src))
        copy(temp, src)
        copy(dest, temp)
    } else {
        copy(dest, src)
    }
}

---

Use of unsafe Package — High

The unsafe package bypasses Go's type safety and memory safety.

Bad:

import "unsafe"

func UnsafeStringToBytes(s string) []byte {
    return (*[0x7fffffff]byte)(unsafe.Pointer(
        (*reflect.StringHeader)(unsafe.Pointer(&s)).Data,
    ))[:len(s):len(s)]  // DON'T: memory corruption risk
}

func TypePun(value uint64) float64 {
    return *(*float64)(unsafe.Pointer(&value))  // DON'T
}

Good:

// Safe string encoding
func StringToBytes(s string) []byte {
    return []byte(s)
}
func BytesToString(b []byte) string {
    return string(b)
}

// Safe type conversion
import "encoding/binary"
func Uint64ToFloat64(value uint64) float64 {
    buf := make([]byte, 8)
    binary.LittleEndian.PutUint64(buf, value)
    bits := binary.LittleEndian.Uint64(buf)
    return math.Float64frombits(bits)
}

---

Data Races — High

Go's race detector is your primary defense.

Bad:

type Counter struct {
    value int
}

func (c *Counter) Increment() {
    c.value++  // DON'T: Data race without sync
}

Good:

import "sync"

type Counter struct {
    value int
    mu    sync.Mutex
}

func (c *Counter) Increment() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.value++
}

// Or atomic for simple cases
import "sync/atomic"
type AtomicCounter struct {
    value int64
}
func (c *AtomicCounter) Increment() {
    atomic.AddInt64(&c.value, 1)
}

Always Run Race Detector

go test -race ./...
go build -race

---

CWE References

• CWE-190: Integer Overflow or Wraparound
• CWE-119: Improper Restriction of Operations within Bounds
• CWE-125: Out-of-bounds Read
• CWE-787: Out-of-bounds Write
• CWE-362: Race Condition
• CWE-367: Time-of-check Time-of-use (TOCTOU)

Network/Web Security Rules

Network and web security vulnerabilities can lead to data leakage and unauthorized access.

Rules:

1. Redirects MUST be validated against an allowlist of domains. 2. HTTP servers MUST configure ReadTimeout, WriteTimeout, and IdleTimeout. 3. Pprof endpoints MUST NEVER be exposed publicly. 4. XML parsers MUST disable XXE — reject <!DOCTYPE and <!ENTITY declarations.

---

Open Redirect Vulnerability — Medium

Redirects to unvalidated URLs can be used for phishing.

Bad:

target := r.URL.Query().Get("url")
http.Redirect(w, r, target, http.StatusFound) // DON'T

Good:

target := r.URL.Query().Get("url")
u, _ := url.Parse(target)
// Only allow http/https
if u.Scheme != "http" && u.Scheme != "https" {
    return errors.New("invalid scheme")
}
// Block javascript/data schemes
if strings.HasPrefix(target, "javascript:") || strings.HasPrefix(target, "data:") {
    return errors.New("blocked scheme")
}
// Check against whitelist
if !isAllowedDomain(u.Host) {
    return errors.New("invalid domain")
}
http.Redirect(w, r, target, http.StatusFound)

---

Bind to All Interfaces — Medium

Binding to 0.0.0.0 exposes services to all network interfaces.

Bad:

listener, _ := net.Listen("tcp", "0.0.0.0:8080") // DON'T: Exposes all interfaces

Good:

// Bind only to localhost
listener, _ := net.Listen("tcp", "127.0.0.1:8080")

// Or specific internal IP
listener, _ := net.Listen("tcp", "10.0.1.5:8080")

---

Slowloris Attack Vulnerability — Medium

Slowloris attacks exhaust connection pools.

Bad:

server := &http.Server{
    Addr: ":8080",
    // Missing ReadTimeout, WriteTimeout, IdleTimeout
}

Good:

server := &http.Server{
    Addr:         ":8080",
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  120 * time.Second,
    MaxHeaderBytes: 1 << 20, // Limit header size to 1MB
}

---

Insecure HTTP Server Configuration — Medium

Running HTTP servers without proper security settings.

Bad:

http.ListenAndServe(":8080", handler) // DON'T: No security hardening

Good:

server := &http.Server{
    Addr:         ":443",
    ReadTimeout:  5 * time.Second,
    WriteTimeout: 10 * time.Second,
    IdleTimeout:  120 * time.Second,
    MaxHeaderBytes: 1 << 20,
}
server.ListenAndServeTLS("cert.pem", "key.pem")

---

Observable Timing (Timing Attacks) — Medium

Timing differences can leak sensitive information.

Bad:

func checkPassword(input, secret string) bool {
    return input == secret // DON'T: Short-circuit leaks length
}

Good:

import "crypto/subtle"

// For comparing fixed-length tokens or hashes:
func checkToken(input, expected string) bool {
    // ConstantTimeCompare already handles unequal lengths without leaking timing
    return subtle.ConstantTimeCompare([]byte(input), []byte(expected)) == 1
}

// For passwords, use Argon2id (preferred) or bcrypt — they handle hashing
// and constant-time comparison internally:
// argon2: hash := argon2.IDKey([]byte(password), salt, 3, 64*1024, 4, 32)
// bcrypt: err := bcrypt.CompareHashAndPassword([]byte(storedHash), []byte(password))

// For HMAC verification:
import "crypto/hmac"
func verifyHMAC(message, messageMAC, key []byte) bool {
    mac := hmac.New(sha256.New, key)
    mac.Write(message)
    expectedMAC := mac.Sum(nil)
    return hmac.Equal(messageMAC, expectedMAC) // Constant-time
}

---

Exposed pprof Profiling Endpoints — High

Debug pprof endpoints expose sensitive runtime information.

Bad:

import _ "net/http/pprof" // DON'T: Automatically registers /debug/pprof
http.ListenAndServe(":8080", handler)

Good:

// Option 1: Use build tags to exclude pprof from production builds
// File: debug_pprof.go
//go:build !production

package main

import _ "net/http/pprof"

// Option 2: Serve pprof on a separate internal-only listener
func startDebugServer() {
    debugMux := http.NewServeMux()
    debugMux.HandleFunc("/debug/pprof/", pprof.Index)
    debugMux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
    debugMux.HandleFunc("/debug/pprof/profile", pprof.Profile)
    debugMux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
    debugMux.HandleFunc("/debug/pprof/trace", pprof.Trace)
    go http.ListenAndServe("127.0.0.1:6060", debugMux) // localhost only
}

---

XXE Vulnerability — High

XML parsers that process external entity references.

Bad:

decoder := xml.NewDecoder(bytes.NewReader(xmlData))
decoder.Decode(&person) // DON'T: May process external entities

Good:

decoder := xml.NewDecoder(bytes.NewReader(xmlData))
decoder.Strict = true

// Block DTD declarations
xmlStr := string(xmlData)
if strings.Contains(xmlStr, "<!DOCTYPE") || strings.Contains(xmlStr, "<!ENTITY") {
    return errors.New("XML contains DTD - potential XXE")
}
decoder.Decode(&person)

---

Permissive Regex Validation — Low

Weak regex validation can allow malicious input.

Bad:

matched, _ := regexp.MatchString(`.+@.+\..+`, email) // DON'T: Too permissive

Good:

var emailRegex = regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`)
if !emailRegex.MatchString(email) {
    return errors.New("invalid email")
}
// Also block injection patterns

---

CWE References

• CWE-601: Open Redirect
• CWE-208: Observable Timing Discrepancy
• CWE-611: Improper Restriction of XML External Entity Reference
• CWE-770: Allocation of Resources Without Limits
• CWE-20: Improper Input Validation
• CWE-200: Exposure of Sensitive Information

Secrets Management Security Rules

Hardcoded secrets, credentials, and sensitive data in source code is a major security vulnerability.

Rules:

1. Secrets MUST be loaded from environment variables or secret managers. 2. NEVER commit secrets to VCS. 3. .gitignore MUST exclude secret files (.env, *.key, *.pem).

---

Hardcoded Secrets and Credentials — Critical

Bad:

const (
    AWS_ACCESS_KEY    = "AKIAIOSFODNN7EXAMPLE"  // DON'T
    AWS_SECRET_KEY    = "wJalrXUtnFEMI/K7MDENG"  // DON'T
    DATABASE_PASSWORD = "SuperSecret123!"         // DON'T
    JWT_SECRET        = "my-super-secret-jwt-key" // DON'T
)

var config = Config{
    APIKey:  "abc123-xyz789-secret-key", // DON'T
    Secret:  "my-super-secret-value",    // DON'T
    DatabaseURL: "user:passw0rd!@localhost:5432/db", // DON'T
}

Good:

import "os"

type Config struct {
    AWSAccessKey     string
    AWSSecretKey     string
    DatabasePassword string
    JWTSecret        string
}

func LoadConfig() (*Config, error) {
    cfg := &Config{
        AWSAccessKey:     os.Getenv("AWS_ACCESS_KEY_ID"),
        AWSSecretKey:     os.Getenv("AWS_SECRET_ACCESS_KEY"),
        DatabasePassword: os.Getenv("DATABASE_PASSWORD"),
        JWTSecret:        os.Getenv("JWT_SECRET"),
    }

    if cfg.JWTSecret == "" {
        return nil, errors.New("JWT_SECRET is required")
    }
    return cfg, nil
}

---

Hardcoded Database Passwords — Critical

Bad:

// MySQL
dsn := "user:Password123!@tcp(localhost:3306)/dbname" // DON'T

// PostgreSQL
dsn := "user=postgres password=P@ssw0rd! dbname=mydb host=localhost" // DON'T

Good:

// MySQL
func connectMySQL() (*sql.DB, error) {
    user := os.Getenv("DB_USER")
    password := os.Getenv("DB_PASSWORD")
    if password == "" {
        return nil, errors.New("DB_PASSWORD required")
    }
    host := getEnvWithDefault("DB_HOST", "localhost")
    port := getEnvWithDefault("DB_PORT", "3306")
    addr := net.JoinHostPort(host, port)
    dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s",
        user, password, addr, getEnvWithDefault("DB_NAME", "mydb"))
    return sql.Open("mysql", dsn)
}

// PostgreSQL
func connectPostgres() (*sql.DB, error) {
    connStr := os.Getenv("DATABASE_URL")
    if connStr == "" {
        return nil, errors.New("DATABASE_URL required")
    }
    return sql.Open("postgres", connStr)
}

---

Secrets Storage Best Practices

Environment Variables

type EnvSecretLoader struct{}

func (l *EnvSecretLoader) Load(required []string) (map[string]string, error) {
    secrets := make(map[string]string)
    missing := []string{}
    for _, name := range required {
        value := os.Getenv(name)
        if value == "" {
            missing = append(missing, name)
            continue
        }
        secrets[name] = value
    }
    if len(missing) > 0 {
        return nil, fmt.Errorf("missing: %v", missing)
    }
    return secrets, nil
}

Secret Managers

type SecretManager interface {
    GetSecret(name string) (string, error)
}

// AWS Secrets Manager
type AWSSecretsManager struct {
    client *secretsmanager.Client
}

func (m *AWSSecretsManager) GetSecret(name string) (string, error) {
    result, err := m.client.GetSecretValue(context.TODO(), &secretsmanager.GetSecretValueInput{
        SecretId: aws.String(name),
    })
    if err != nil {
        return "", err
    }
    if result.SecretString != nil {
        return *result.SecretString, nil
    }
    return string(result.SecretBinary), nil
}

.gitignore Patterns

# Secrets
.env
.env.local
.env.*.local
*.key
*.pem
*.p12
*.pfx
secrets/
credentials/

---

Secret Detection Patterns

---

CWE References

• CWE-798: Use of Hard-coded Credentials
• CWE-312: Cleartext Storage of Sensitive Information
• CWE-532: Insertion of Sensitive Information into Log File
• CWE-359: Exposure of Private Personal Information

Third-Party Data Leak Rules

Third-party monitoring and analytics services can inadvertently transmit sensitive user data to external systems.

Rules:

1. PII MUST be filtered before sending to third-party services. 2. Error tracking MUST NOT receive raw user data — use BeforeSend hooks to redact.

---

Overview

These rules detect Go code that sends data to third-party services. Always review what data is being transmitted and ensure it complies with privacy regulations (GDPR, CCPA, etc.).

---

Common Vulnerable Services

---

Error Tracking Services — Medium

Bad:

import "github.com/getsentry/sentry-go"

sentry.CaptureException(err) // DON'T: Captures full request context

Good:

sentry.Init(sentry.ClientOptions{
    Dsn: "https://xxx@sentry.io/123",
    RequestHeaders: []string{"Accept", "User-Agent"},
    BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
        // Remove sensitive headers
        if event.Request != nil {
            delete(event.Request.Headers, "Authorization")
            delete(event.Request.Headers, "Cookie")
        }
        return event
    },
})

---

Analytics/Monitoring Services — Medium

Bad:

analytics.Track("user_signed_up", analytics.Properties{
    "email":   user.Email,   // DON'T: PII!
    "phone":   user.Phone,   // DON'T: PII!
    "address": user.Address, // DON'T: PII!
})

Good:

analytics.Track("user_signed_up", analytics.Properties{
    "user_id":        user.ID,          // OK: Internal identifier
    "plan":           user.Plan,        // OK: Business data
    "country":        user.CountryCode, // OK: Non-identifying
})

// Hash PII for correlation
func hashEmail(email string) string {
    h := sha256.New()
    h.Write([]byte(email))
    return hex.EncodeToString(h.Sum(nil))[:8]
}

---

Data Filtering Layer

type DataFilter struct {
    sensitiveFields []string
}

func NewDataFilter() *DataFilter {
    return &DataFilter{
        sensitiveFields: []string{
            "password", "token", "secret", "key", "email",
            "phone", "address", "ssn", "credit_card", "bank_account",
        },
    }
}

func (f *DataFilter) Filter(data map[string]interface{}) map[string]interface{} {
    result := make(map[string]interface{})
    for k, v := range data {
        keyLower := strings.ToLower(k)
        isSensitive := false
        for _, field := range f.sensitiveFields {
            if strings.Contains(keyLower, field) {
                isSensitive = true
                break
            }
        }
        if isSensitive {
            result[k] = "[REDACTED]"
        } else {
            result[k] = v
        }
    }
    return result
}

---

Review Checklist

Before integrating any third-party service:

• [ ] Identify what data is being sent
• [ ] Remove any PII/PHI from transmitted data
• [ ] Review data residency requirements
• [ ] Implement data retention policies
• [ ] Set up data export logging/auditing
• [ ] Configure error handling to avoid data exposure
• [ ] Review terms of service for data usage
• [ ] Implement user consent management
• [ ] Support data deletion requests
• [ ] Conduct regular data flow audits

---

CWE References

• CWE-200: Exposure of Sensitive Information
• CWE-359: Exposure of Private Personal Information
• CWE-201: Information Exposure Through Sent Data