Realllfo

https://github.com/wongyithong1/realllfo
Admin
A project with an unspecified purpose, as only a title is provided in the repository's README.
Tokens:4,083
Snippets:17
Trust Score:3.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### Establish WebSocket Client Connection in Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

This Go code demonstrates how to initialize and run a WebSocket client for the Realllfo system. It handles connection to a specified server URL, prompts for an API key if needed, authenticates, establishes the WebSocket connection, and starts a heartbeat mechanism to wait for task assignments. Dependencies include the 'client/websocket' and 'log' packages.

```go
package main

import (
    "client/websocket"
    "log"
)

func main() {
    // Create WebSocket client
    serverURL := "ws://localhost:8080/ws"
    developerMode := false

    client, err := websocket.NewClient(serverURL, developerMode)
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }

    // Run client (blocks until shutdown)
    // The client will:
    // - Prompt for API key if not stored
    // - Authenticate with server
    // - Establish WebSocket connection
    // - Start heartbeat mechanism
    // - Wait for task assignments
    if err := client.Run(); err != nil {
        log.Fatalf("Client error: %v", err)
    }
}
```

--------------------------------

### Implement Client Security with Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Initializes the client-side security system, managing token storage, encryption, and expiration checks. It uses AES encryption for sensitive data transmission and handles token refresh logic. Dependencies include 'client/security' and 'time'.

```go
package main

import (
    "client/security"
    "server/security"
    "time"
)

func setupClientSecurity() {
    // Initialize client security system
    clientSecurity, _ := security.NewSecuritySystem()

    // Store credentials after successful authentication
    tokenStorage := clientSecurity.GetTokenStorage()
    tokenStorage.SaveToken(
        "jwt-session-token",
        "client-hwid",
        time.Now().Add(24 * time.Hour),
        []byte("aes-encryption-key"),
    )

    // Encrypt sensitive data before transmission
    encService := clientSecurity.GetEncryptionService()
    apiKey := "user-api-key"
    encryptionKey := tokenStorage.GetEncryptionKey()

    encryptedAPIKey, _ := encService.EncryptAPIKey(apiKey, encryptionKey)

    // Check token expiration
    if tokenStorage.IsExpired() {
        // Request token refresh
    } else if tokenStorage.IsNearExpiry() {
        // Proactively refresh before expiration
    }
}
```

--------------------------------

### Web Crawler Implementation in Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

This Go code snippet showcases the web crawling functionality within Realllfo. It initializes an HTTP client and a web crawler, then proceeds to crawl a target URL. The output includes extracted information such as the domain, original URL, link count, discovered parameters (from URLs, JS, forms, and APIs), and a list of API endpoints with their methods, URLs, and sources. Dependencies include 'client/module/crawler', 'client/module/waf', 'context', 'fmt', and 'time'.

```go
package main

import (
    "client/module/crawler"
    "client/module/waf"
    "context"
    "fmt"
    "time"
)

func main() {
    // Create HTTP client and crawler
    httpClient := waf.NewHTTPClient()
    webCrawler := crawler.NewCrawler(httpClient)

    // Crawl target URL
    ctx := context.Background()
    targetURL := "https://example.com/search?q=test&page=1"

    result := webCrawler.Crawl(ctx, targetURL)

    // Output results
    fmt.Printf("Domain: %s\n", result.Domain)
    fmt.Printf("Original URL: %s\n", result.OriginalURL)
    fmt.Printf("Links Count: %d\n", result.LinksCount)
    fmt.Printf("Extracted Parameters: %v\n", result.ExtractedParams)
    // Example: ["q", "page", "user_id", "token", "callback"]

    fmt.Printf("API Endpoints Found: %d\n", len(result.APIEndpoints))
    for _, endpoint := range result.APIEndpoints {
        fmt.Printf("  - %s %s (from %s)\n",
            endpoint.Method, endpoint.URL, endpoint.Source)
    }
    // Example output:
    //   - GET /api/users (from js)
    //   - POST /api/login (from form)

    fmt.Printf("Crawled URLs: %d\n", len(result.CrawledURLs))
}
```

--------------------------------

### WAF Detection with Go Client

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Automates Web Application Firewall detection using payload triggering and fingerprinting. It configures a WAF detector with proxies, sets progress callbacks, and detects WAFs on a list of URLs, processing the results to determine protection status.

```go
package main

import (
    "client/module/waf"
    "context"
    "fmt"
    "time"
)

func main() {
    // Configure WAF detector with proxies
    proxies := []*waf.Proxy{
        {URL: "http://proxy1.example.com:8080"},
        {URL: "http://proxy2.example.com:8080"},
    }

    workerCount := 5
    timeout := "30s"
    detector, err := waf.NewDetector(workerCount, timeout, proxies)
    if err != nil {
        panic(err)
    }

    // Set progress callback
    detector.SetProgressCallback(func(taskID string, result *waf.DetectionResult,
                                      progress, completed, total int) {
        fmt.Printf("[%d%%] %s: %s (Status: %s)\n",
            progress, result.URL, result.WAFType, result.Status)
    })

    // Detect WAF on multiple URLs
    urls := []string{
        "https://example1.com",
        "https://example2.com",
        "https://example3.com",
    }

    ctx := context.Background()
    taskID := "task-123"
    startIndex := 0

    results, err := detector.Detect(ctx, taskID, urls, startIndex)
    if err != nil {
        fmt.Printf("Detection error: %v\n", err)
        return
    }

    // Process results
    for _, result := range results {
        switch result.Status {
        case waf.StatusCompleted:
            fmt.Printf("✓ %s: Protected by %s\n", result.URL, result.WAFType)
        case waf.StatusNoWAF:
            fmt.Printf("○ %s: No WAF detected\n", result.URL)
        case waf.StatusOffline:
            fmt.Printf("✗ %s: Offline\n", result.URL)
        }
    }
}
```

--------------------------------

### Client Authentication and Session Management in Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Illustrates the client-side authentication flow for Realllfo. It shows the structure of an authentication request sent by the client, including the API key and optional hardware identifier (HWID). The server's successful login response includes details like machine ID, session token, encryption key, and token expiration. The client then securely stores these credentials using a hypothetical security system. This code is illustrative and part of a larger system.

```go
// Client sends AUTH_REQUEST with API key
authRequest := models.Message{
    Type: models.MessageTypeAuthRequest,
    Data: models.AuthRequestData{
        APIKey: "your-api-key-here",
        HWID:   existingHWID, // Optional: for reconnection
    },
}

// Server validates API key and responds with LOGIN_SUCCESS
loginSuccess := models.LoginSuccessData{
    MachineID:      "machine-uuid",
    HWID:           "generated-hwid",
    SessionToken:   "jwt-token",
    EncryptionKey:  "base64-encoded-aes-key",
    TokenExpiresAt: 1735689600,
    Message:        "Login successful",
}

// Client stores credentials securely
securitySystem.GetTokenStorage().SaveToken(
    loginSuccess.SessionToken,
    loginSuccess.HWID,
    time.Unix(loginSuccess.TokenExpiresAt, 0),
    []byte(loginSuccess.EncryptionKey),
)
```

--------------------------------

### Implement Server Security Features with Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Sets up server-side security, including HWID generation, session token management, and rate limiting. It generates unique hardware identifiers, creates and validates JWT tokens, and enforces request rate limits. Dependencies include 'server/security' and 'time'.

```go
package main

import (
    "client/security"
    "server/security"
    "time"
)

func setupServerSecurity() {
    // Initialize server security system
    serverSecurity, _ := security.NewSecuritySystem()

    // Generate HWID for new machine
    hwidGen := serverSecurity.GetHWIDGenerator()
    hwid := hwidGen.GenerateHWID("user-id-123", "machine-id-456")

    // Generate session token
    tokenManager := serverSecurity.GetTokenManager()
    token, expiresAt, _ := tokenManager.GenerateToken("user-id", "api-key")

    // Validate token in subsequent requests
    claims, err := tokenManager.ValidateToken(token)
    if err == nil {
        userID := claims.UserID
        // Process authenticated request
    }

    // Rate limiting
    rateLimiter := serverSecurity.GetRateLimiter()
    allowed := rateLimiter.Allow("client-ip-address")
    if !allowed {
        // Reject request - rate limit exceeded
    }
}
```

--------------------------------

### Server WebSocket Hub with Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Implements a central WebSocket hub to manage client connections and distribute tasks. It initializes various services like authentication, machine management, and security, then sets up an HTTP server to handle WebSocket upgrades and client registrations.

```go
package main

import (
    "server/websocket"
    "server/service"
    "server/database"
    "server/security"
    "net/http"
    "log"
)

func main() {
    // Initialize services
    db, _ := database.NewDB("supabase-url", "supabase-key")
    authService := service.NewAuthService(db)
    machineService := service.NewMachineService(db)
    taskProgressService := service.NewTaskProgressService(db)
    securitySystem, _ := security.NewSecuritySystem()
    payloadCacheService, _ := service.NewPayloadCacheService(db, securitySystem)

    // Create and start hub
    hub := websocket.NewHub(
        authService,
        machineService,
        taskProgressService,
        securitySystem,
        payloadCacheService,
    )
    go hub.Run()

    // WebSocket endpoint handler
    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            log.Printf("Upgrade failed: %v", err)
            return
        }

        client := websocket.NewClient(hub, conn)
        hub.RegisterClient(client, "")

        go client.WritePump()
        go client.ReadPump()
    })

    log.Fatal(http.ListenAndServe(":8080", nil))
}
```

--------------------------------

### Go Graceful Shutdown Implementation

Source: https://context7.com/wongyithong1/realllfo/llms.txt

This Go code snippet demonstrates a graceful shutdown sequence for a service. It listens for OS interrupt signals (SIGINT, SIGTERM), initiates a shutdown process with a timeout, and logs any errors. The shutdown process involves pausing tasks, updating machine status, closing connections, and flushing data.

```go
package main

import (
    "context"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    // Server graceful shutdown
    shutdownService := service.NewShutdownService(db, taskMonitor, hub)

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

    // Wait for shutdown signal
    <-sigChan

    // Execute graceful shutdown within timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := shutdownService.GracefulShutdown(ctx); err != nil {
        log.Printf("Shutdown error: %v", err)
    }

    // Shutdown process:
    // 1. Pause all running tasks and save progress
    // 2. Set all machines to offline status
    // 3. Close WebSocket connections gracefully
    // 4. Flush logs and cached data to database
    // 5. Close database connections
}

func startupTaskRecovery(db *database.DB) {
    // Server startup - pause all running tasks
    // (they were running when server shut down)
    ctx := context.Background()
    tasks, _ := db.GetAllRunningTasks(ctx)

    for _, task := range tasks {
        db.UpdateTaskStatus(ctx, task.ID, "paused")
    }

    // Tasks will resume when clients reconnect
    // and server sends TASK_ASSIGNMENT messages
}
```

--------------------------------

### Manage Machine Status and Pausing Tasks with Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Sets up machine lifecycle management, detecting online/offline status and automatically pausing tasks. It utilizes a WebSocket hub to monitor disconnections and trigger task pauses. Dependencies include 'server/service' and 'websocket'.

```go
package main

import (
    "server/service"
    "time"
)

func setupMachineManagement(machineService *service.MachineService,
                            hub *websocket.Hub) {
    // Set machine offline callback
    hub.SetMachineOfflineCallback(func(machineID string) {
        // This is called 15 seconds after disconnection
        // if machine hasn't reconnected
        taskMonitor.PauseTasksForMachine(machineID)
    })

    // Machine connects
    machineInfo := models.MachineInfoData{
        RAM:  "16GB",
        Core: 8,
        IP:   "192.168.1.100",
        Name: "worker-01",
        HWID: "generated-hwid",
    }

    // Server updates machine status to online
    machineService.UpdateMachineStatusToOnline(machineID)

    // Machine disconnects - delayed pause triggered
    // After 15 seconds without reconnection:
    // - Tasks are automatically paused
    // - Machine status set to offline
    // - Progress is saved to database
}
```

--------------------------------

### Track Task Progress with Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Monitors and updates task progress in real-time using Go. It simulates server requests for progress and client responses, storing data in a cache before periodic database synchronization. Dependencies include 'server/models' and 'server/service'.

```go
package main

import (
    "server/models"
    "server/service"
)

func monitorTaskProgress(taskMonitor *service.TaskMonitorService, taskID string) {
    // Server requests progress from client
    progressRequest := models.TaskProgressRequestData{
        TaskID: taskID,
    }

    // Client responds with current progress
    progressResponse := models.TaskProgressResponseData{
        TaskID: taskID,
        Domains: []string{
            "example.com",
            "api.example.com",
            "shop.example.com",
        },
        WAF: []string{
            "cloudflare",
            "no waf",
            "generic",
        },
        Status: []string{
            "completed",
            "completed",
            "completed",
        },
        Links: []int{
            15, // example.com has 15 parameters
            8,  // api.example.com has 8 parameters
            23, // shop.example.com has 23 parameters
        },
        Database: []string{
            "MySQL 5.7",
            "",
            "PostgreSQL 13",
        },
        CurrentURL: 150,  // Processed 150 URLs
        TotalURL:   500,  // Total 500 URLs in list
    }

    // Progress is cached and periodically written to database
    // Cache structure: map[taskID]*CachedProgress
}
```

--------------------------------

### Task Assignment and Management with Go

Source: https://context7.com/wongyithong1/realllfo/llms.txt

Handles the distribution of security scanning tasks to connected client machines. It defines functions to prepare task data, including URLs, settings, and payloads, and send it to a specific machine via the WebSocket hub. It also includes a placeholder for client-side task handling and acknowledgment.

```go
package main

import (
    "server/models"
    "server/websocket"
    "encoding/base64"
)

func assignTaskToMachine(hub *websocket.Hub, hwid string) error {
    // Prepare task assignment data
    taskData := &models.TaskAssignmentMessageData{
        TaskID:    "task-uuid-123",
        TaskName:  "Security Scan - example.com",
        MachineID: "machine-uuid-456",
        FileURLs: models.TaskFileURLs{
            ListFileURL:  "https://storage.example.com/urls.txt",
            ProxyFileURL: "https://storage.example.com/proxies.txt",
            ListFileName: "urls.txt",
            ProxyFileName: "proxies.txt",
        },
        Settings: models.TaskSettings{
            Worker:           10,
            Timeout:          "30s",
            AutoDumper:       true,
            DumperWorker:     5,
            DumperPresetType: "mysql",
            DumperTimeout:    "60s",
            DumperMinRows:    100,
            AIMode:           false,
        },
        CreatedAt:    "2025-12-07T10:30:00Z",
        CurrentLines: 0, // Start from beginning
        // Encrypted payloads included by hub automatically
    }

    // Send task to machine
    err := hub.SendTaskToMachine(hwid, taskData)
    if err != nil {
        return err
    }

    return nil
}

// Client receives and processes task
func handleTaskAssignment(msg *models.Message) {
    var taskData models.TaskAssignmentData
    // Parse and validate task data...

    // Send acknowledgment
    ack := models.Message{
        Type: models.MessageTypeTaskAssignmentAck,
        Data: models.TaskAssignmentAckData{
            TaskID:  taskData.TaskID,
            Status:  "accepted",
            Message: "Task started successfully",
        },
    }
    // Send ack message back to server...
}
```
Tokens:
Raw