Files
ssw-mvp/scard/code/server/audit/logger.go
T
admin 3247e9fd15 init: ssw-mvp initial commit
- boot/ (Java/Maven, JNPF 7.0) — 移除旧的 boot/.git,源码直接纳入仓库
- web/ (Vue 3 + Vite + Ant Design Vue, pnpm)
- docs/, scard/, nax/
- refs/INDEX.md + refs/国标/(其余 refs/* 开源子仓库不纳入)
- 已忽略: connector_data/, jweb/, log/, web/{dist,node_modules,.pnpm}, boot/*/target/, .DS_Store, .idea, .vscode
2026-08-05 18:29:12 +08:00

238 lines
5.2 KiB
Go

// Audit logging module
package audit
import (
"encoding/json"
"fmt"
"os"
"path/filepath"
"sync"
"time"
"security-connector/common/types"
)
// Logger handles audit logging
type Logger struct {
mu sync.Mutex
// Log file handle
file *os.File
filePath string
// In-memory buffer for batch writing
buffer []*types.AuditEvent
// Flush interval
flushInterval time.Duration
// Channel for async logging
logChan chan *types.AuditEvent
// Stop channel
stopChan chan struct{}
}
// NewLogger creates a new audit logger
func NewLogger(logDir string) (*Logger, error) {
if err := os.MkdirAll(logDir, 0755); err != nil {
return nil, fmt.Errorf("failed to create log directory: %w", err)
}
// Generate log file name with date
logFileName := fmt.Sprintf("audit_%s.jsonl", time.Now().Format("2006-01-02"))
logFilePath := filepath.Join(logDir, logFileName)
file, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return nil, fmt.Errorf("failed to open log file: %w", err)
}
logger := &Logger{
file: file,
filePath: logFilePath,
buffer: make([]*types.AuditEvent, 0, 100),
flushInterval: 5 * time.Second,
logChan: make(chan *types.AuditEvent, 1000),
stopChan: make(chan struct{}),
}
// Start background flusher
go logger.backgroundFlusher()
return logger, nil
}
// Log logs an audit event
func (l *Logger) Log(event *types.AuditEvent) {
// Generate ID and timestamp if not set
if event.ID == "" {
event.ID = generateEventID()
}
if event.Timestamp.IsZero() {
event.Timestamp = time.Now()
}
// Send to channel for async processing
select {
case l.logChan <- event:
default:
// Buffer full, log directly
l.writeEvent(event)
}
}
// writeEvent writes an event to the log file
func (l *Logger) writeEvent(event *types.AuditEvent) {
l.mu.Lock()
defer l.mu.Unlock()
data, err := json.Marshal(event)
if err != nil {
fmt.Fprintf(os.Stderr, "failed to marshal audit event: %v\n", err)
return
}
// Write as JSON line
if _, err := l.file.Write(append(data, '\n')); err != nil {
fmt.Fprintf(os.Stderr, "failed to write audit event: %v\n", err)
return
}
}
// backgroundFlusher periodically flushes the buffer
func (l *Logger) backgroundFlusher() {
ticker := time.NewTicker(l.flushInterval)
defer ticker.Stop()
for {
select {
case event := <-l.logChan:
l.writeEvent(event)
case <-ticker.C:
l.flush()
case <-l.stopChan:
l.flush()
return
}
}
}
// flush flushes the buffer to disk
func (l *Logger) flush() {
l.mu.Lock()
defer l.mu.Unlock()
// Flush file
if l.file != nil {
if err := l.file.Sync(); err != nil {
fmt.Fprintf(os.Stderr, "failed to sync audit log: %v\n", err)
}
}
}
// Close closes the logger
func (l *Logger) Close() error {
close(l.stopChan)
l.mu.Lock()
defer l.mu.Unlock()
if l.file != nil {
return l.file.Close()
}
return nil
}
// generateEventID generates a unique event ID
func generateEventID() string {
return fmt.Sprintf("%s_%d", time.Now().Format("20060102150405"), time.Now().UnixNano()%1000000)
}
// LogDeviceRegister logs a device registration event
func (l *Logger) LogDeviceRegister(deviceID, result, errorCode, ipAddress string) {
l.Log(&types.AuditEvent{
EventType: types.AuditDeviceRegister,
DeviceID: deviceID,
Result: result,
ErrorCode: errorCode,
IPAddress: ipAddress,
})
}
// LogDeviceAuth logs a device authentication event
func (l *Logger) LogDeviceAuth(deviceID, result, errorCode, ipAddress string) {
l.Log(&types.AuditEvent{
EventType: types.AuditDeviceAuth,
DeviceID: deviceID,
Result: result,
ErrorCode: errorCode,
IPAddress: ipAddress,
})
}
// LogKeyUpdate logs a key update event
func (l *Logger) LogKeyUpdate(deviceID, keyID string, version int, result, errorCode string) {
details, _ := json.Marshal(map[string]interface{}{
"key_id": keyID,
"version": version,
})
l.Log(&types.AuditEvent{
EventType: types.AuditKeyUpdate,
DeviceID: deviceID,
Result: result,
ErrorCode: errorCode,
Details: details,
})
}
// LogEasytierJoin logs an EasyTier join event
func (l *Logger) LogEasytierJoin(deviceID, nodeID, networkID, result, errorCode string) {
details, _ := json.Marshal(map[string]interface{}{
"node_id": nodeID,
"network_id": networkID,
})
l.Log(&types.AuditEvent{
EventType: types.AuditEasytierJoin,
DeviceID: deviceID,
Result: result,
ErrorCode: errorCode,
Details: details,
})
}
// LogK3sJoin logs a k3s join event
func (l *Logger) LogK3sJoin(deviceID, nodeName, clusterID, result, errorCode string) {
details, _ := json.Marshal(map[string]interface{}{
"node_name": nodeName,
"cluster_id": clusterID,
})
l.Log(&types.AuditEvent{
EventType: types.AuditK3sJoin,
DeviceID: deviceID,
Result: result,
ErrorCode: errorCode,
Details: details,
})
}
// LogPolicyDeny logs a policy denial event
func (l *Logger) LogPolicyDeny(deviceID, subject, action, resource string) {
details, _ := json.Marshal(map[string]interface{}{
"subject": subject,
"action": action,
"resource": resource,
})
l.Log(&types.AuditEvent{
EventType: types.AuditPolicyDeny,
DeviceID: deviceID,
Result: "deny",
Details: details,
})
}