Telmo · May 6, 2016 12:29 · Mar 6, 2016 · Jul 19, 2015 · Feb 20, 2015 · Mar 29, 2012
diff --git a/golang-tls.md b/golang-tls.md
@@ -139,5 +139,8 @@ func main() {
 ```
 
 
-##### Links
-* http://superuser.com/a/226229/205366
+Links
+---
+- http://superuser.com/a/226229/205366
+- https://gist.github.com/spikebike/2232102
+- http://echo.labstack.com/guide/
diff --git a/golang-tls.md b/golang-tls.md
@@ -136,4 +136,8 @@ func main() {
 
     println(string(buf[:n]))
 }
-```
+```
+
+
+##### Links
+* http://superuser.com/a/226229/205366
diff --git a/client.go b/client.go
@@ -1,43 +0,0 @@
-package main
-
-import (
-    "crypto/tls"
-    "crypto/x509"
-    "fmt"
-    "io"
-    "log"
-)
-
-func main() {
-    cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
-    if err != nil {
-        log.Fatalf("server: loadkeys: %s", err)
-    }
-    config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true}
-    conn, err := tls.Dial("tcp", "127.0.0.1:8000", &config)
-    if err != nil {
-        log.Fatalf("client: dial: %s", err)
-    }
-    defer conn.Close()
-    log.Println("client: connected to: ", conn.RemoteAddr())
-
-    state := conn.ConnectionState()
-    for _, v := range state.PeerCertificates {
-        fmt.Println(x509.MarshalPKIXPublicKey(v.PublicKey))
-        fmt.Println(v.Subject)
-    }
-    log.Println("client: handshake: ", state.HandshakeComplete)
-    log.Println("client: mutual: ", state.NegotiatedProtocolIsMutual)
-
-    message := "Hello\n"
-    n, err := io.WriteString(conn, message)
-    if err != nil {
-        log.Fatalf("client: write: %s", err)
-    }
-    log.Printf("client: wrote %q (%d bytes)", message, n)
-
-    reply := make([]byte, 256)
-    n, err = conn.Read(reply)
-    log.Printf("client: read %q (%d bytes)", string(reply[:n]), n)
-    log.Print("client: exiting")
-}

diff --git a/golang-tls.md b/golang-tls.md
@@ -0,0 +1,139 @@
+#### Generated private key
+
+    openssl genrsa -out server.key 2048
+
+#### To generate a certificate
+
+    openssl req -new -x509 -key server.key -out server.pem -days 3650
+
+#### https
+
+```go
+package main
+
+import (
+    "io"
+    "net/http"
+    "log"
+)
+
+func HelloServer(w http.ResponseWriter, req *http.Request) {
+    io.WriteString(w, "hello, world!\n")
+}
+
+func main() {
+    http.HandleFunc("/hello", HelloServer)
+    err := http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)
+    if err != nil {
+        log.Fatal("ListenAndServe: ", err)
+    }
+}
+```
+
+Hint: visit, please do not forget to use https begins,otherwise chrome will download a file as follows:
+
+```bash
+dotcoo-air:tls dotcoo$ cat /Users/dotcoo/Downloads/hello | xxd
+0000000: 1503 0100 0202 0a                        .......
+```
+
+#### TLS Server
+
+```go
+package main
+
+import (
+    "log"
+    "crypto/tls"
+    "net"
+    "bufio"
+)
+
+func main() {
+    log.SetFlags(log.Lshortfile)
+
+    cer, err := tls.LoadX509KeyPair("server.pem", "server.key")
+    if err != nil {
+        log.Println(err)
+        return
+    }
+
+    config := &tls.Config{Certificates: []tls.Certificate{cer}}
+    ln, err := tls.Listen("tcp", ":443", config) 
+    if err != nil {
+        log.Println(err)
+        return
+    }
+    defer ln.Close()
+
+    for {
+        conn, err := ln.Accept()
+        if err != nil {
+            log.Println(err)
+            continue
+        }
+        go handleConnection(conn)
+    }
+}
+
+func handleConnection(conn net.Conn) {
+    defer conn.Close()
+    r := bufio.NewReader(conn)
+    for {
+        msg, err := r.ReadString('\n')
+        if err != nil {
+            log.Println(err)
+            return
+        }
+
+        println(msg)
+
+        n, err := conn.Write([]byte("world\n"))
+        if err != nil {
+            log.Println(n, err)
+            return
+        }
+    }
+}
+```
+
+#### TLS Client
+
+```go
+package main
+
+import (
+    "log"
+    "crypto/tls"
+)
+
+func main() {
+    log.SetFlags(log.Lshortfile)
+
+    conf := &tls.Config{
+        InsecureSkipVerify: true,
+    }
+
+    conn, err := tls.Dial("tcp", "127.0.0.1:8000", conf)
+    if err != nil {
+        log.Println(err)
+        return
+    }
+    defer conn.Close()
+
+    n, err := conn.Write([]byte("hello\n"))
+    if err != nil {
+        log.Println(n, err)
+        return
+    }
+
+    buf := make([]byte, 100)
+    n, err = conn.Read(buf)
+    if err != nil {
+        log.Println(n, err)
+        return
+    }
+
+    println(string(buf[:n]))
+}
+```
diff --git a/makecert.sh b/makecert.sh
@@ -1,10 +0,0 @@
-#!/bin/bash
-# call this script with an email address (valid or not).
-# like:
-# ./makecert.sh [email protected]
-mkdir certs
-rm certs/*
-echo "make server cert"
-openssl req -new -nodes -x509 -out certs/server.pem -keyout certs/server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/emailAddress=$1"
-echo "make client cert"
-openssl req -new -nodes -x509 -out certs/client.pem -keyout certs/client.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/emailAddress=$1"

diff --git a/server.go b/server.go
@@ -1,68 +0,0 @@
-package main
-
-import (
-    "crypto/rand"
-    "crypto/tls"
-    "log"
-    "net"
-    "crypto/x509"
-)
-
-func main() {
-    cert, err := tls.LoadX509KeyPair("certs/server.pem", "certs/server.key")
-    if err != nil {
-        log.Fatalf("server: loadkeys: %s", err)
-    }
-    config := tls.Config{Certificates: []tls.Certificate{cert}}
-    config.Rand = rand.Reader
-    service := "0.0.0.0:8000"
-    listener, err := tls.Listen("tcp", service, &config)
-    if err != nil {
-        log.Fatalf("server: listen: %s", err)
-    }
-    log.Print("server: listening")
-    for {
-        conn, err := listener.Accept()
-        if err != nil {
-            log.Printf("server: accept: %s", err)
-            break
-        }
-        defer conn.Close()
-        log.Printf("server: accepted from %s", conn.RemoteAddr())
-        tlscon, ok := conn.(*tls.Conn)
-        if ok {
-            log.Print("ok=true")
-            state := tlscon.ConnectionState()
-            for _, v := range state.PeerCertificates {
-                log.Print(x509.MarshalPKIXPublicKey(v.PublicKey))
-            }
-        }
-        go handleClient(conn)
-    }
-}
-
-func handleClient(conn net.Conn) {
-    defer conn.Close()
-    buf := make([]byte, 512)
-    for {
-        log.Print("server: conn: waiting")
-        n, err := conn.Read(buf)
-        if err != nil {
-            if err != nil {
-                log.Printf("server: conn: read: %s", err)
-            }
-            break
-        }
-        log.Printf("server: conn: echo %q\n", string(buf[:n]))
-        n, err = conn.Write(buf[:n])
-
-        n, err = conn.Write(buf[:n])
-        log.Printf("server: conn: wrote %d bytes", n)
-
-        if err != nil {
-            log.Printf("server: write: %s", err)
-            break
-        }
-    }
-    log.Println("server: conn: closed")
-}

diff --git a/makecert.sh b/makecert.sh
@@ -1,5 +1,7 @@
 #!/bin/bash
 # call this script with an email address (valid or not).
+# like:
+# ./makecert.sh [email protected]
 mkdir certs
 rm certs/*
 echo "make server cert"

diff --git a/makecert.sh b/makecert.sh
@@ -1,4 +1,5 @@
 #!/bin/bash
+# call this script with an email address (valid or not).
 mkdir certs
 rm certs/*
 echo "make server cert"

diff --git a/server.go b/server.go
@@ -32,11 +32,11 @@ func main() {
         tlscon, ok := conn.(*tls.Conn)
         if ok {
             log.Print("ok=true")
+            state := tlscon.ConnectionState()
+            for _, v := range state.PeerCertificates {
+                log.Print(x509.MarshalPKIXPublicKey(v.PublicKey))
+            }
         }
-        state := tlscon.ConnectionState()
-        for _, v := range state.PeerCertificates {
-            log.Print(x509.MarshalPKIXPublicKey(v.PublicKey))
-        }   
         go handleClient(conn)
     }
 }

diff --git a/client.go b/client.go
@@ -1,46 +1,43 @@
 package main
 
 import (
-	"crypto/tls"
-	"crypto/x509"
-	"fmt"
-	"io"
-	"log"
+    "crypto/tls"
+    "crypto/x509"
+    "fmt"
+    "io"
+    "log"
 )
 
 func main() {
-	cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
-	if err != nil {
-		log.Fatalf("server: loadkeys: %s", err)
-	}
-	config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true}
-	conn, err := tls.Dial("tcp", "127.0.0.1:8000", &config)
-	if err != nil {
-		log.Fatalf("client: dial: %s", err)
-	}
-	defer conn.Close()
-	log.Println("client: connected to: ", conn.RemoteAddr())
+    cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
+    if err != nil {
+        log.Fatalf("server: loadkeys: %s", err)
+    }
+    config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true}
+    conn, err := tls.Dial("tcp", "127.0.0.1:8000", &config)
+    if err != nil {
+        log.Fatalf("client: dial: %s", err)
+    }
+    defer conn.Close()
+    log.Println("client: connected to: ", conn.RemoteAddr())
 
-	state := conn.ConnectionState()
-	for _, v := range state.PeerCertificates {
-		fmt.Println(x509.MarshalPKIXPublicKey(v.PublicKey))
-		fmt.Println(v.EmailAddresses)
-		fmt.Println(v.DNSNames)
-		fmt.Println("subject")
-		fmt.Println(v.Subject)
-	}
-	log.Println("client: handshake: ", state.HandshakeComplete)
-	log.Println("client: mutual: ", state.NegotiatedProtocolIsMutual)
+    state := conn.ConnectionState()
+    for _, v := range state.PeerCertificates {
+        fmt.Println(x509.MarshalPKIXPublicKey(v.PublicKey))
+        fmt.Println(v.Subject)
+    }
+    log.Println("client: handshake: ", state.HandshakeComplete)
+    log.Println("client: mutual: ", state.NegotiatedProtocolIsMutual)
 
-	message := "Hello\n"
-	n, err := io.WriteString(conn, message)
-	if err != nil {
-		log.Fatalf("client: write: %s", err)
-	}
-	log.Printf("client: wrote %q (%d bytes)", message, n)
+    message := "Hello\n"
+    n, err := io.WriteString(conn, message)
+    if err != nil {
+        log.Fatalf("client: write: %s", err)
+    }
+    log.Printf("client: wrote %q (%d bytes)", message, n)
 
-	reply := make([]byte, 256)
-	n, err = conn.Read(reply)
-	log.Printf("client: read %q (%d bytes)", string(reply[:n]), n)
-	log.Print("client: exiting")
+    reply := make([]byte, 256)
+    n, err = conn.Read(reply)
+    log.Printf("client: read %q (%d bytes)", string(reply[:n]), n)
+    log.Print("client: exiting")
 }
diff --git a/server.go b/server.go
@@ -5,47 +5,44 @@ import (
     "crypto/tls"
     "log"
     "net"
+    "crypto/x509"
 )
 
 func main() {
-
     cert, err := tls.LoadX509KeyPair("certs/server.pem", "certs/server.key")
     if err != nil {
         log.Fatalf("server: loadkeys: %s", err)
     }
     config := tls.Config{Certificates: []tls.Certificate{cert}}
-
     config.Rand = rand.Reader
-
     service := "0.0.0.0:8000"
-
     listener, err := tls.Listen("tcp", service, &config)
     if err != nil {
         log.Fatalf("server: listen: %s", err)
     }
-
     log.Print("server: listening")
     for {
         conn, err := listener.Accept()
-
         if err != nil {
             log.Printf("server: accept: %s", err)
             break
         }
         defer conn.Close()
         log.Printf("server: accepted from %s", conn.RemoteAddr())
-        tlscon, ok := conn.(tls.Conn)
-        if ok == true {
-            state := tlscon.ConnectionState()
+        tlscon, ok := conn.(*tls.Conn)
+        if ok {
+            log.Print("ok=true")
         }
-
+        state := tlscon.ConnectionState()
+        for _, v := range state.PeerCertificates {
+            log.Print(x509.MarshalPKIXPublicKey(v.PublicKey))
+        }   
         go handleClient(conn)
     }
 }
 
 func handleClient(conn net.Conn) {
     defer conn.Close()
-
     buf := make([]byte, 512)
     for {
         log.Print("server: conn: waiting")
@@ -55,9 +52,10 @@ func handleClient(conn net.Conn) {
                 log.Printf("server: conn: read: %s", err)
             }
             break
-
-       }
+        }
         log.Printf("server: conn: echo %q\n", string(buf[:n]))
+        n, err = conn.Write(buf[:n])
+
         n, err = conn.Write(buf[:n])
         log.Printf("server: conn: wrote %d bytes", n)
 

diff --git a/client.go b/client.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+	"io"
+	"log"
+)
+
+func main() {
+	cert, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
+	if err != nil {
+		log.Fatalf("server: loadkeys: %s", err)
+	}
+	config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true}
+	conn, err := tls.Dial("tcp", "127.0.0.1:8000", &config)
+	if err != nil {
+		log.Fatalf("client: dial: %s", err)
+	}
+	defer conn.Close()
+	log.Println("client: connected to: ", conn.RemoteAddr())
+
+	state := conn.ConnectionState()
+	for _, v := range state.PeerCertificates {
+		fmt.Println(x509.MarshalPKIXPublicKey(v.PublicKey))
+		fmt.Println(v.EmailAddresses)
+		fmt.Println(v.DNSNames)
+		fmt.Println("subject")
+		fmt.Println(v.Subject)
+	}
+	log.Println("client: handshake: ", state.HandshakeComplete)
+	log.Println("client: mutual: ", state.NegotiatedProtocolIsMutual)
+
+	message := "Hello\n"
+	n, err := io.WriteString(conn, message)
+	if err != nil {
+		log.Fatalf("client: write: %s", err)
+	}
+	log.Printf("client: wrote %q (%d bytes)", message, n)
+
+	reply := make([]byte, 256)
+	n, err = conn.Read(reply)
+	log.Printf("client: read %q (%d bytes)", string(reply[:n]), n)
+	log.Print("client: exiting")
+}
diff --git a/makecert.sh b/makecert.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+mkdir certs
+rm certs/*
+echo "make server cert"
+openssl req -new -nodes -x509 -out certs/server.pem -keyout certs/server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/emailAddress=$1"
+echo "make client cert"
+openssl req -new -nodes -x509 -out certs/client.pem -keyout certs/client.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=www.random.com/emailAddress=$1"
diff --git a/server.go b/server.go
@@ -0,0 +1,70 @@
+package main
+
+import (
+    "crypto/rand"
+    "crypto/tls"
+    "log"
+    "net"
+)
+
+func main() {
+
+    cert, err := tls.LoadX509KeyPair("certs/server.pem", "certs/server.key")
+    if err != nil {
+        log.Fatalf("server: loadkeys: %s", err)
+    }
+    config := tls.Config{Certificates: []tls.Certificate{cert}}
+
+    config.Rand = rand.Reader
+
+    service := "0.0.0.0:8000"
+
+    listener, err := tls.Listen("tcp", service, &config)
+    if err != nil {
+        log.Fatalf("server: listen: %s", err)
+    }
+
+    log.Print("server: listening")
+    for {
+        conn, err := listener.Accept()
+
+        if err != nil {
+            log.Printf("server: accept: %s", err)
+            break
+        }
+        defer conn.Close()
+        log.Printf("server: accepted from %s", conn.RemoteAddr())
+        tlscon, ok := conn.(tls.Conn)
+        if ok == true {
+            state := tlscon.ConnectionState()
+        }
+
+        go handleClient(conn)
+    }
+}
+
+func handleClient(conn net.Conn) {
+    defer conn.Close()
+
+    buf := make([]byte, 512)
+    for {
+        log.Print("server: conn: waiting")
+        n, err := conn.Read(buf)
+        if err != nil {
+            if err != nil {
+                log.Printf("server: conn: read: %s", err)
+            }
+            break
+
+       }
+        log.Printf("server: conn: echo %q\n", string(buf[:n]))
+        n, err = conn.Write(buf[:n])
+        log.Printf("server: conn: wrote %d bytes", n)
+
+        if err != nil {
+            log.Printf("server: write: %s", err)
+            break
+        }
+    }
+    log.Println("server: conn: closed")
+}