first implementation of secure

main.go

@@ -12,7 +12,7 @@ type Server interface {
 	
 func main() {
 	var challenge int
-	flag.IntVar(&challenge, "challenge",7, "Challenge number")
+	flag.IntVar(&challenge, "challenge",8, "Challenge number")
 	flag.Parse()
 	
 	var port uint16 
@@ -35,6 +35,8 @@ func main() {
 	  	server = NewSpeedServer(port);
     case 7:
 	  	server = NewReverseServer(port);
+    case 8:
+	  	server = NewSecureServer(port);
 		default:
 			fmt.Printf("Unknown challenge\n")
 			os.Exit(1)

secure.go

@@ -0,0 +1,108 @@
+package main
+
+import (
+"net"
+"os"
+"fmt"
+"bufio"
+"strings"
+"strconv"
+)
+
+func largestOrder(msg string) string {
+  orders := strings.Split(msg, ",")
+  largest := 0
+  result := ""
+  for i := range orders {
+    l := orders[i]
+    parts := strings.Split(l, "x")
+    amount, err := strconv.Atoi(parts[0])
+    if err == nil && amount > largest {
+      largest = amount
+      result = l
+    }
+  }
+  return result
+}
+
+type SecureServer struct {
+	port uint16
+}
+
+func NewSecureServer(port uint16) *SecureServer {
+	return &SecureServer{
+		port,
+	}
+}
+
+type SecureSession struct{
+	con net.Conn
+}
+
+func NewSecureSession(con net.Conn) *SecureSession {
+	return &SecureSession{
+		con,
+	}
+}
+
+
+func (s *SecureServer) Run() {
+	addr := fmt.Sprintf("0.0.0.0:%d", s.port)
+	server, err := net.Listen("tcp", addr)
+    if err != nil {
+      fmt.Println("Error listening:", err.Error())
+        os.Exit(1)
+    }
+    defer server.Close()
+    fmt.Println("SecureServer waiting for client...")
+    for {
+      connection, err := server.Accept()
+      if err != nil {
+        fmt.Println("Error accepting: ", err.Error())
+        os.Exit(1)
+      }
+      fmt.Println("client connected")
+      s.processClient(connection)
+		}
+	
+}
+
+func (s *SecureServer) processClient(con net.Conn) {
+	
+	session := NewSecureSession( con)
+	go session.SecureReceiver()
+}
+
+
+func (s *SecureSession) setEncryption(r *bufio.Reader) error {
+	secdef, err := r.ReadBytes('\x00')
+	if err != nil { return err }
+  fmt.Printf("secdef: %s\n", secdef)
+	return nil
+}
+
+func (s *SecureSession) query(r *bufio.Reader) error {
+	msg, err := r.ReadString('\n')
+	if err != nil { return err }
+	msg = strings.TrimSpace(msg)
+  fmt.Printf("Q: %s", msg)
+  a := largestOrder(msg)
+  fmt.Printf("A: %s\n", a)
+  s.con.Write(append([]byte(a), []byte("\n")...))
+	return nil
+}
+
+func (s *SecureSession) close() {
+	fmt.Printf("close\n")
+  s.con.Close()
+}
+
+func (s *SecureSession) SecureReceiver() {
+	defer s.close()
+	r := bufio.NewReaderSize(s.con, 5000)
+	err := s.setEncryption(r)
+	for err == nil {
+		err = s.query(r)
+	}
+}
+

tests/secure.py

@@ -0,0 +1,16 @@
+import socket
+from struct import pack, unpack
+from time import time, sleep
+
+def sock():
+  addr = ("localhost", 13370)
+  s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+  s.connect(addr)
+  return s
+  
+def test(s):
+  s.sendall(b"\x0010x snoeperfloep,123x sapperflap\n")
+  print(s.recv(1024))
+  s.close()
+
+test(sock())