feat: add v2 phase2 security policy

internal/sysinfo/sysinfo.go

@@ -7,15 +7,30 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 )
 
+var netMu sync.Mutex
+var lastNet = struct {
+	rx, tx uint64
+	at     time.Time
+}{}
+
 type Profile struct {
 	Role            string  `json:"role,omitempty"`
 	CPUCores        int     `json:"cpu_cores"`
 	CPUUsagePercent int     `json:"cpu_usage_percent"`
 	Load1M          float64 `json:"load_1m"`
+	Load5M          float64 `json:"load_5m"`
+	Load15M         float64 `json:"load_15m"`
+	NetRXRate       float64 `json:"net_rx_rate"`
+	NetTXRate       float64 `json:"net_tx_rate"`
+	NetRXTotal      uint64  `json:"net_rx_total"`
+	NetTXTotal      uint64  `json:"net_tx_total"`
+	UptimeSeconds   float64 `json:"uptime_seconds"`
+	BootTime        int64   `json:"boot_time"`
 	MemPercent      int     `json:"mem_percent"`
 	MemAvailable    string  `json:"mem_available"`
 	DiskPercent     int     `json:"disk_percent"`
@@ -36,7 +51,9 @@ func Collect(defaultRole string) Profile {
 
 	cores := runtime.NumCPU()
 	cpuPercent := getCPUUsage()
-	load1m := getLoad1M()
+	load1m, load5m, load15m := getLoads()
+	netRX, netTX, netRXT, netTXT := getNetwork()
+	uptime, boot := getUptime()
 	memPct, memAvl := getMemInfo()
 	diskPct, diskFree := getDiskInfo()
 	psi := getIOPSI()
@@ -47,6 +64,14 @@ func Collect(defaultRole string) Profile {
 		CPUCores:        cores,
 		CPUUsagePercent: cpuPercent,
 		Load1M:          load1m,
+		Load5M:          load5m,
+		Load15M:         load15m,
+		NetRXRate:       netRX,
+		NetTXRate:       netTX,
+		NetRXTotal:      netRXT,
+		NetTXTotal:      netTXT,
+		UptimeSeconds:   uptime,
+		BootTime:        boot,
 		MemPercent:      memPct,
 		MemAvailable:    memAvl,
 		DiskPercent:     diskPct,
@@ -57,16 +82,70 @@ func Collect(defaultRole string) Profile {
 	}
 }
 
-func getLoad1M() float64 {
-	if data, err := os.ReadFile("/proc/loadavg"); err == nil {
-		fields := strings.Fields(string(data))
-		if len(fields) > 0 {
-			if val, err := strconv.ParseFloat(fields[0], 64); err == nil {
-				return val
-			}
+func getLoads() (float64, float64, float64) {
+	data, err := os.ReadFile("/proc/loadavg")
+	if err != nil {
+		return 0, 0, 0
+	}
+	f := strings.Fields(string(data))
+	if len(f) < 3 {
+		return 0, 0, 0
+	}
+	v := func(i int) float64 { x, _ := strconv.ParseFloat(f[i], 64); return x }
+	return v(0), v(1), v(2)
+}
+
+func getNetwork() (float64, float64, uint64, uint64) {
+	data, err := os.ReadFile("/proc/net/dev")
+	if err != nil {
+		return 0, 0, 0, 0
+	}
+	var rx, tx uint64
+	for _, line := range strings.Split(string(data), "\n") {
+		parts := strings.SplitN(line, ":", 2)
+		if len(parts) != 2 || strings.TrimSpace(parts[0]) == "lo" {
+			continue
+		}
+		f := strings.Fields(parts[1])
+		if len(f) < 9 {
+			continue
+		}
+		r, e1 := strconv.ParseUint(f[0], 10, 64)
+		t, e2 := strconv.ParseUint(f[8], 10, 64)
+		if e1 == nil && e2 == nil {
+			rx += r
+			tx += t
 		}
 	}
-	return 0.0
+	now := time.Now()
+	netMu.Lock()
+	defer netMu.Unlock()
+	var rr, tr float64
+	if !lastNet.at.IsZero() && now.After(lastNet.at) && rx >= lastNet.rx && tx >= lastNet.tx {
+		d := now.Sub(lastNet.at).Seconds()
+		if d > 0 {
+			rr = float64(rx-lastNet.rx) / d
+			tr = float64(tx-lastNet.tx) / d
+		}
+	}
+	lastNet.rx, lastNet.tx, lastNet.at = rx, tx, now
+	return rr, tr, rx, tx
+}
+
+func getUptime() (float64, int64) {
+	data, err := os.ReadFile("/proc/uptime")
+	if err != nil {
+		return 0, time.Now().Unix()
+	}
+	f := strings.Fields(string(data))
+	if len(f) == 0 {
+		return 0, time.Now().Unix()
+	}
+	u, err := strconv.ParseFloat(f[0], 64)
+	if err != nil {
+		return 0, time.Now().Unix()
+	}
+	return u, time.Now().Add(-time.Duration(u * float64(time.Second))).Unix()
 }
 
 func getCPUUsage() int {