modularized and cleaned up the code (4e7ce87c) · Commits · bsmrgo / perplex

cmd/perplex-client/main.go

+8 −56

Original line number	Diff line number	Diff line
		package main

		import (
		"crypto/tls"
		"crypto/x509"
		"fmt"
		"log"
		"net"

		"repositories.muehmer.net/bsmrgo/perplex/internal/pkg/perplex"
		"repositories.muehmer.net/bsmrgo/perplex/pkg/perplexsdk"
		"repositories.muehmer.net/bsmrgo/perplex/internal/app/client"
		"repositories.muehmer.net/bsmrgo/perplex/internal/app/client/channel"
		)

		func main() {
		log.Printf("Started perplex client.")
		log.Printf("Started %s.", client.Name())
		defer log.Printf("Terminating %s...", client.Name())

		//tcpClient()
		tlsClient()

		log.Printf("Terminating perplex client...")
		}

		func tcpClient() {
		conn, err := net.Dial("tcp", perplex.ServernameTCP("localhost"))
		if err != nil {
		log.Panic(err)
		}
		defer conn.Close()
		log.Printf("Connected to: %v->%v", conn.LocalAddr(), conn.RemoteAddr())

		handleServer(conn)

		log.Printf("Disconnecting from: %v->%v", conn.LocalAddr(), conn.RemoteAddr())
		}

		func tlsClient() {
		cert, err := tls.LoadX509KeyPair("../../scripts/certs/client.pem", "../../scripts/certs/client.key")
		if err != nil {
		log.Fatalf("client: loadkeys: %s", err)
		}
		config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true}
		conn, err := tls.Dial("tcp", perplex.ServernameTLS("localhost"), &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)

		handleServer(conn)

		log.Print("client: exiting")
		}

		func handleServer(conn net.Conn) {
		// we should do something...
		log.Printf(perplexsdk.Dummy())
		// get rolling...
		serverHostname := "localhost"
		//channel.TCPClient(serverHostname, client.Handle)
		channel.TLSClient(serverHostname, client.Handle)
		}

cmd/perplex-server/main.go

+7 −129

Original line number	Diff line number	Diff line
		package main

		import (
		"bufio"
		"crypto/rand"
		"crypto/tls"
		"crypto/x509"
		"log"
		"net"

		"repositories.muehmer.net/bsmrgo/perplex/internal/pkg/perplex"
		"repositories.muehmer.net/bsmrgo/perplex/internal/app/server"
		"repositories.muehmer.net/bsmrgo/perplex/internal/app/server/channel"
		)

		func main() {
		log.Printf("Started perplex server.")
		log.Printf("Started %s.", server.Name())
		defer log.Printf("Terminating %s...", server.Name())

		//tcpServer()
		tlsServer()
		}

		func tcpServer() {
		ln, err := net.Listen("tcp", perplex.ServernameTCP(""))
		if err != nil {
		log.Fatal(err)
		}
		defer ln.Close()
		for {
		conn, err := ln.Accept()
		if err != nil {
		log.Printf("Accept() failed with: %v", err)
		}
		//go handleTCPClient(conn)
		go handleClient(conn)
		}
		}

		func handleTCPClient(conn net.Conn) {
		defer conn.Close()
		log.Printf("Connected from: %v->%v", conn.RemoteAddr(), conn.LocalAddr())

		banner := "Welcome to perplex!\n"
		_, err := conn.Write([]byte(banner))
		if err != nil {
		log.Print(err)
		}
		reader := bufio.NewReader(conn)
		loop := true
		for loop {
		line, _, err := reader.ReadLine()
		if err != nil {
		log.Print(err)
		} else {
		text := string(line)
		switch text {
		case "help":
		help := `
		The perplex server currently understands:
		help : display this text
		quit : terminate the connection
		`
		conn.Write([]byte(help))
		case "quit":
		loop = false
		conn.Write([]byte("Good-Bye!\n"))
		}
		}
		}

		log.Printf("Disconnected from: %v->%v", conn.RemoteAddr(), conn.LocalAddr())
		}

		func tlsServer() {
		cert, err := tls.LoadX509KeyPair("../../scripts/certs/server.pem", "../../scripts/certs/server.key")
		if err != nil {
		log.Fatalf("server: loadkeys: %s", err)
		}
		config := tls.Config{Certificates: []tls.Certificate{cert}}
		config.Rand = rand.Reader
		listener, err := tls.Listen("tcp", perplex.ServernameTLS(""), &config)
		if err != nil {
		log.Fatal(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 handleTLSClient(conn)
		go handleClient(conn)
		}
		}

		func handleTLSClient(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")
		}

		func handleClient(conn net.Conn) {
		defer conn.Close()
		log.Printf("Connected from: %v->%v", conn.RemoteAddr(), conn.LocalAddr())

		// read and write stuff over connection

		log.Printf("Disconnected from: %v->%v", conn.RemoteAddr(), conn.LocalAddr())
		// get rolling...
		//channel.TCPServer(server.Handle)
		channel.TLSServer(server.Handle)
		}

internal/app/client/channel/tcp.go

0 → 100644

+19 −0

Original line number	Diff line number	Diff line
		package channel

		import (
		"log"
		"net"

		"repositories.muehmer.net/bsmrgo/perplex/internal/pkg/perplex"
		)

		// TCPClient prepares a plain TCP connection.
		func TCPClient(hostname string, handler func(net.Conn)) {
		conn, err := net.Dial("tcp", perplex.ServernameTCP(hostname))
		if err != nil {
		log.Panic(err)
		}
		defer conn.Close()

		handler(conn)
		}

internal/app/client/channel/tls.go

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		package channel

		import (
		"crypto/tls"
		"log"
		"net"

		"repositories.muehmer.net/bsmrgo/perplex/internal/pkg/perplex"
		)

		// TLSClient prepares a TLS secured connection.
		func TLSClient(hostname string, handler func(net.Conn)) {
		cert, err := tls.LoadX509KeyPair("../../scripts/certs/client.pem", "../../scripts/certs/client.key")
		if err != nil {
		log.Fatal(err)
		}

		config := tls.Config{Certificates: []tls.Certificate{cert}, InsecureSkipVerify: true}
		conn, err := tls.Dial("tcp", perplex.ServernameTLS(hostname), &config)
		if err != nil {
		log.Fatal(err)
		}
		defer conn.Close()

		peerCertificates(conn)
		handler(conn)
		}

		func peerCertificates(conn *tls.Conn) {
		state := conn.ConnectionState()
		for _, v := range state.PeerCertificates {
		//log.Println(x509.MarshalPKIXPublicKey(v.PublicKey))
		log.Printf("peer certificate: %s", v.Subject)
		}
		}

internal/app/client/handler.go

0 → 100644

+28 −0

Original line number	Diff line number	Diff line
		package client

		import (
		"fmt"
		"log"
		"net"

		"repositories.muehmer.net/bsmrgo/perplex/pkg/perplexsdk"
		)

		// Handle handles a server connection.
		func Handle(conn net.Conn) {
		log.Printf("Connected: %v->%v", conn.LocalAddr(), conn.RemoteAddr())
		defer log.Printf("Disconnected: %v->%v", conn.LocalAddr(), conn.RemoteAddr())

		// we should do something...
		msg := fmt.Sprintf("Hello Server! We use the %s.", perplexsdk.Name())

		conn.Write([]byte(msg))

		buffer := make([]byte, 1024)
		if n, err := conn.Read(buffer); err != nil {
		log.Print(err)
		} else {
		text := string(buffer[:n])
		log.Printf("got %d bytes %v = %s", n, buffer[:n], text)
		}
		}