TLS and X. Certificates: Your Digital Passport and Secure Tunnel, Go Crypto 7

import (
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "io/ioutil"
)

func main() {
    // Let's read our digital passport
    certPEM, err := ioutil.ReadFile("my_digital_passport.pem")
    if err != nil {
        panic("Oops! We lost our passport!")
    }

    // Decode the PEM block (it's like opening the passport)
    block, _ := pem.Decode(certPEM)
    if block == nil {
        panic("This doesn't look like a passport...")
    }

    // Parse the certificate (reading the passport details)
    cert, err := x509.ParseCertificate(block.Bytes)
    if err != nil {
        panic("We can't read this passport!")
    }

    // Let's see what's in our passport
    fmt.Printf("Passport owner: %s\n", cert.Subject)
    fmt.Printf("Passport issuer: %s\n", cert.Issuer)
    fmt.Printf("Valid from: %s\n", cert.NotBefore)
    fmt.Printf("Valid until: %s\n", cert.NotAfter)
}

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "crypto/x509"
    "crypto/x509/pkix"
    "encoding/pem"
    "math/big"
    "os"
    "time"
)

func main() {
    // Let's create our secret key
    privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
    if err != nil {
        panic("Our key generator is feeling shy!")
    }

    // Now, let's fill out our passport application
    template := x509.Certificate{
        SerialNumber: big.NewInt(1),
        Subject: pkix.Name{
            Organization: []string{"Gopher's Cryptographic Adventures"},
        },
        NotBefore: time.Now(),
        NotAfter:  time.Now().Add(time.Hour * 24 * 180), // Valid for 180 days

        KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
        ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
        BasicConstraintsValid: true,
    }

    // Time to create our passport!
    derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &privateKey.PublicKey, privateKey)
    if err != nil {
        panic("The passport printer is jammed!")
    }

    // Let's save our new passport
    certOut, err := os.Create("my_new_passport.pem")
    if err != nil {
        panic("We can't save our new passport!")
    }
    pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
    certOut.Close()

    // And let's keep our secret key safe
    keyOut, err := os.Create("my_secret_key.pem")
    if err != nil {
        panic("We can't save our secret key!")
    }
    pem.Encode(keyOut, &pem.Block{Type: "EC PRIVATE KEY", Bytes: x509.MarshalECPrivateKey(privateKey)})
    keyOut.Close()

    fmt.Println("Congratulations! You've got a new digital passport!")
}

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

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to our secure tunnel!")
}

func main() {
    http.HandleFunc("/", handler)

    // Let's load our digital passport and secret key
    cert, err := tls.LoadX509KeyPair("my_new_passport.pem", "my_secret_key.pem")
    if err != nil {
        panic("We can't find our passport or secret key!")
    }

    // Now, let's set up our secure tunnel
    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{cert},
    }

    // Time to open our secure office
    server := &http.Server{
        Addr:      ":443",
        TLSConfig: tlsConfig,
    }

    // Let's start welcoming visitors!
    fmt.Println("Our secure office is open at https://localhost:443")
    err = server.ListenAndServeTLS("", "")
    if err != nil {
        panic("Oops! We couldn't open our office!")
    }
}

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    // Let's load the passport of the server we want to visit
    certPool := x509.NewCertPool()
    pem, err := ioutil.ReadFile("server_passport.pem")
    if err != nil {
        panic("We can't find the server's passport!")
    }
    if !certPool.AppendCertsFromPEM(pem) {
        panic("This doesn't look like a valid passport...")
    }

    // Now, let's prepare for our secure journey
    tlsConfig := &tls.Config{
        RootCAs: certPool,
    }

    // Time to create our secure transport
    client := &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: tlsConfig,
        },
    }

    // Let's visit the secure server!
    resp, err := client.Get("https://example.com")
    if err != nil {
        panic("Our secure journey failed!")
    }
    defer resp.Body.Close()

    // What did the server say?
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        panic("We couldn't understand the server's message!")
    }
    fmt.Printf("The server says: %s\n", body)
}