Networking and Security

🌐 Networking & Security in Go: Your Secret Agent Toolkit

Imagine you’re a secret agent. You need to send coded messages across the world, make sure nobody can peek at them, and verify that your messages reach the right person. That’s exactly what networking and security in Go helps you do!

🎯 What We’ll Discover

1. Network Connections — Making phone calls across the internet
2. TLS and HTTPS — Wrapping your messages in an unbreakable safe
3. Cryptographic Operations — The art of secret codes

📞 Network Connections: Talking Across the Internet

The Story: Your Digital Phone Line

Think of your computer like a house. Every house needs a phone to talk to other houses. Network connections are how computers call each other!

TCP vs UDP: Two Ways to Talk

TCP is like a phone call:

• You dial → Person picks up → You talk → Both know the call happened
• Reliable: Every word is heard in order

UDP is like throwing paper airplanes:

• You throw it → Hope it arrives
• Fast but unreliable: Some airplanes might get lost!

🛠️ Making Your First Connection (TCP Client)

package main

import (
    "fmt"
    "net"
)

func main() {
    // Dial = Pick up phone
    // and call this address
    conn, err := net.Dial("tcp",
        "example.com:80")
    if err != nil {
        fmt.Println("Call failed:", err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected!")
}

What’s happening?

• net.Dial = “Hello, I want to connect!”
• "tcp" = We want reliable delivery
• "example.com:80" = Address (house) + Port (room number)

🏠 Creating a Server (Listening for Calls)

package main

import (
    "fmt"
    "net"
)

func main() {
    // Listen = Set up phone
    // to receive calls
    listener, err := net.Listen(
        "tcp", ":8080")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer listener.Close()

    fmt.Println("Waiting for calls...")

    for {
        // Accept = Answer the phone
        conn, _ := listener.Accept()
        go handleCall(conn)
    }
}

func handleCall(conn net.Conn) {
    defer conn.Close()
    conn.Write([]byte("Hello caller!"))
}

📬 UDP: The Fast Way

// UDP Server
addr, _ := net.ResolveUDPAddr(
    "udp", ":9000")
conn, _ := net.ListenUDP("udp", addr)

buffer := make([]byte, 1024)
n, sender, _ := conn.ReadFromUDP(buffer)
fmt.Printf("Got: %s from %s\n",
    buffer[:n], sender)

graph TD
    A["Your Computer"] -->|Dial| B["Network"]
    B -->|Connect| C["Server"]
    C -->|Accept| D["Connection Made!"]
    D -->|Read/Write| E["Exchange Messages"]

🔒 TLS and HTTPS: The Unbreakable Safe

The Story: Sending Treasure Safely

Imagine sending a treasure chest across town. Anyone could open it! But what if you:

1. Lock it with a special lock
2. Only the receiver has the key
3. The chest screams if someone tries to break in

That’s TLS! It’s like a magical safe for your internet messages.

What TLS Does

🌟 HTTPS = HTTP + TLS

HTTP  = Sending a postcard (everyone can read it)
HTTPS = Sending a locked safe (only receiver can open)

🛠️ Creating a Secure HTTPS Server

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w
        http.ResponseWriter, r
        *http.Request) {
        fmt.Fprintf(w,
            "You're safe here! 🔒")
    })

    // Start HTTPS server
    // cert.pem = Your ID card
    // key.pem = Your secret key
    http.ListenAndServeTLS(
        ":443",
        "cert.pem",
        "key.pem",
        nil)
}

🔑 Making a Secure Client Request

package main

import (
    "crypto/tls"
    "fmt"
    "net/http"
)

func main() {
    // Configure TLS settings
    tlsConfig := &tls.Config{
        MinVersion: tls.VersionTLS12,
    }

    // Create secure transport
    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, _ := client.Get(
        "https://example.com")
    defer resp.Body.Close()

    fmt.Println("Status:", resp.Status)
}

🎭 Custom TLS Configuration

// Skip verification
// (ONLY for testing!)
tlsConfig := &tls.Config{
    InsecureSkipVerify: true,
}

// Proper production config
tlsConfig := &tls.Config{
    MinVersion: tls.VersionTLS12,
    CipherSuites: []uint16{
        tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
        tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
    },
}

graph TD
    A["Your Browser"] -->|1. Hello| B["Server"]
    B -->|2. Here's my certificate| A
    A -->|3. Let's agree on encryption| B
    B -->|4. Agreed! Safe channel open| A
    A <-->|5. Encrypted messages| B

🔐 Cryptographic Operations: The Secret Code Lab

The Story: Becoming a Code Master

Every spy needs to know codes! Go gives you a whole toolbox:

• Hashing = Creating fingerprints
• Encryption = Scrambling messages
• Signing = Proving you wrote something

🔖 Hashing: Creating Digital Fingerprints

A hash turns any data into a fixed-size “fingerprint”. Same input = same fingerprint. Always!

package main

import (
    "crypto/sha256"
    "fmt"
)

func main() {
    message := "Hello, Go!"

    // Create fingerprint
    hash := sha256.Sum256(
        []byte(message))

    fmt.Printf("Fingerprint: %x\n",
        hash)
}

Popular Hash Functions:

🔄 Encryption: Scramble and Unscramble

AES (Advanced Encryption Standard) is like a magic box:

• Put message in → scrambled text comes out
• Only someone with the key can unscramble it!

package main

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

func encrypt(plaintext []byte,
    key []byte) []byte {

    block, _ := aes.NewCipher(key)

    gcm, _ := cipher.NewGCM(block)

    // Create random nonce
    nonce := make([]byte,
        gcm.NonceSize())
    io.ReadFull(rand.Reader, nonce)

    // Encrypt!
    return gcm.Seal(nonce, nonce,
        plaintext, nil)
}

func decrypt(ciphertext []byte,
    key []byte) []byte {

    block, _ := aes.NewCipher(key)
    gcm, _ := cipher.NewGCM(block)

    nonceSize := gcm.NonceSize()
    nonce := ciphertext[:nonceSize]
    ciphertext = ciphertext[nonceSize:]

    plaintext, _ := gcm.Open(nil,
        nonce, ciphertext, nil)

    return plaintext
}

🔑 Key Lesson: Key Must Be Right Size!

// AES needs 16, 24, or 32 bytes
key16 := []byte("16-byte-key!!!!!")  // AES-128
key24 := []byte("24-byte-key!!!!!!!!!")  // AES-192
key32 := []byte("32-byte-key!!!!!!!!!!!!!!")  // AES-256

✍️ Digital Signatures: Proving It’s Really You

Like signing a document — but mathematically unbreakable!

package main

import (
    "crypto"
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
)

func main() {
    // Generate key pair
    privateKey, _ := rsa.GenerateKey(
        rand.Reader, 2048)
    publicKey := &privateKey.PublicKey

    message := []byte("I agree!")

    // Create hash of message
    hash := sha256.Sum256(message)

    // Sign with private key
    signature, _ := rsa.SignPKCS1v15(
        rand.Reader,
        privateKey,
        crypto.SHA256,
        hash[:])

    // Verify with public key
    err := rsa.VerifyPKCS1v15(
        publicKey,
        crypto.SHA256,
        hash[:],
        signature)

    if err == nil {
        println("Signature valid! ✓")
    }
}

graph TD
    A["Original Message"] -->|Hash| B["Fingerprint"]
    B -->|Sign with Private Key| C["Signature"]
    D["Received Message"] -->|Hash| E["Fingerprint"]
    C -->|Verify with Public Key| F{Match?}
    E --> F
    F -->|Yes| G["✓ Authentic!"]
    F -->|No| H["✗ Tampered!"]

🎲 Generating Secure Random Numbers

Never use math/rand for security! Use crypto/rand:

package main

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

func main() {
    // Generate 32 random bytes
    randomBytes := make([]byte, 32)
    rand.Read(randomBytes)

    fmt.Println("Random key:",
        hex.EncodeToString(randomBytes))
}

🔐 Password Hashing with bcrypt

Never store plain passwords! Use bcrypt:

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

// Hash password
hash, _ := bcrypt.GenerateFromPassword(
    []byte("myPassword123"),
    bcrypt.DefaultCost)

// Check password
err := bcrypt.CompareHashAndPassword(
    hash,
    []byte("myPassword123"))

if err == nil {
    fmt.Println("Password correct!")
}

🎓 Quick Reference Table

🚀 You’re Now a Security Agent!

You’ve learned:

• ✅ How to make network connections (TCP & UDP)
• ✅ How to secure connections with TLS/HTTPS
• ✅ How to hash, encrypt, and sign data

Remember: Security isn’t optional — it’s your digital armor! 🛡️

Now go build something secure and amazing!