Skip to content

Security Overview ​

DD has multi-layered security built in, fully safeguarding log security from data filtering to audit tracing.

Security Layers ​

LayerMechanismDescription
DataSensitive-data filteringAuto-redact passwords, keys, etc.
PathPath-safety validationPrevent path-traversal and symlink attacks
PatternReDoS protectionDetect dangerous regex patterns
AuditAudit loggingRecord key security events (redaction, rate-limit, violations, etc.)
IntegrityHMAC signingEnsure logs are tamper-evident

Which Page to Read First ​

Sensitive-Data Filtering ​

DD has built-in automatic sensitive-data detection and redaction:

go
cfg := dd.DefaultConfig()
cfg.Security = dd.DefaultSecurityConfig() // Basic filtering (already the DefaultConfig default)
logger, _ := dd.New(cfg)

// The password field is auto-redacted
logger.InfoWith("login",
    dd.String("username", "admin"),
    dd.String("password", "s3cr3t"),  // Output: [REDACTED]
)

Supported custom patterns:

go
filter, err := dd.NewCustomSensitiveDataFilter(
    `(?i)password\s*[:=]\s*\S+`,
    `(?i)api[_-]?key\s*[:=]\s*\S+`,
    `\b\d{16,19}\b`,  // Credit card number
)
if err != nil {
    log.Fatal(err) // Regex safety validation failed
}

See Security Filtering API.

Path Security ​

FileWriter has multi-layered path-safety validation built in:

ProtectionDescription
Path traversalReject ../ and similar traversal
Null bytesReject null-byte injection
Overlong encodingDetect UTF-8 overlong encoding
SymlinksUnconditional symlink rejection
HardlinksUnconditional hardlink rejection
Path lengthCap maximum path length
go
// Path-traversal attack auto-rejected
fw, err := dd.NewFileWriter("../../../etc/passwd", dd.DefaultFileWriterConfig())
// err.Error(): "path traversal detected"

Compliance Configuration ​

DD provides industry-compliance presets:

PresetCompliance StandardIndustry
HealthcareConfig()HIPAAMedical
FinancialConfig()PCI-DSSFinancial
GovernmentConfig()Government standardPublic sector
go
// HIPAA compliance
cfg := dd.DefaultConfig()
cfg.Security = dd.HealthcareConfig()
logger, _ := dd.New(cfg)

Audit Logging ​

All security events can be tracked via audit logging:

go
audit, _ := dd.NewAuditLogger(dd.DefaultAuditConfig())
defer audit.Close()

audit.LogSecurityViolation("sql_injection", "SQL injection", map[string]any{
    "input": "' OR 1=1 --",
})

See Audit Logging API.

Log Integrity ​

HMAC signing ensures logs cannot be tampered with:

go
cfg, _ := dd.DefaultIntegrityConfigSafe()
signer, _ := dd.NewIntegritySigner(cfg)
signature := signer.Sign(logMessage)
// On verification: signer.Verify(signedEntry)

See Integrity Signing API.

Rate Limiting ​

SecurityConfig.RateLimitConfig protects against log flooding (DoS). It is off by default — none of the preset security configs populate this field, so it must be enabled explicitly:

go
cfg := dd.DefaultConfig()
cfg.Security = dd.SecurityConfigForLevel(dd.SecurityLevelStandard)
cfg.Security.RateLimitConfig = dd.DefaultRateLimitConfig() // 10,000 msg/s, 10MB/s, burst 1000, RateLimitStrategyDrop strategy
logger, _ := dd.New(cfg)

Three over-limit strategies: RateLimitStrategyDrop discards messages (default); RateLimitStrategySample keeps a fraction when over limit (e.g. 1 in 100); RateLimitStrategyThrottle is kept for API completeness and currently behaves like RateLimitStrategyDrop (the Logger never blocks).

Two Independent Mechanisms

Config.Sampling (Log Sampling) and SecurityConfig.RateLimitConfig (rate limiting) are independent mechanisms: sampling reduces volume periodically via counters, rate limiting caps the rate to prevent flooding; both can be enabled at the same time. See the Security API for rate-limit fields.

Next Steps ​