join via api - netmaker changes

Signed-off-by: Matthew R. Kasun <[email protected]>

controllers/node.go

@@ -1,6 +1,7 @@
 package controller
 
 import (
+	"crypto/ed25519"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -366,8 +367,9 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		Code: http.StatusInternalServerError, Message: "W1R3: It's not you it's me.",
 	}
 	//get node from body of request
-	var request = config.JoinRequest{}
-	err := json.NewDecoder(r.Body).Decode(&request)
+	//var request = config.JoinRequest{}
+	var node = models.Node{}
+	err := json.NewDecoder(r.Body).Decode(&node)
 	if err != nil {
 		log.Println("json decoder error")
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
@@ -375,6 +377,21 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 	}
 
 	//Generate certificate for client
+	//client key
+	_, private, err := ed25519.GenerateKey()
+	if err != nil {
+		log.Println("failed to gen client key", err)
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+	name := tls.NewCName(node.Name)
+	csr, err := tls.NewCSR(private, name)
+	if err != nil {
+		log.Println("failed to gen client csr", err)
+		returnErrorResponse(w, r, formatError(err, "internal"))
+		return
+	}
+
 	key, err := tls.ReadKey("/etc/netmaker/root.key")
 	if err != nil {
 		log.Println("error reading root private key ", err)
@@ -388,17 +405,17 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
-	cert, err := tls.NewEndEntityCert(*key, &request.CSR, ca, 30)
+	cert, err := tls.NewEndEntityCert(*key, csr, ca, 30)
 	if err != nil {
 		log.Println("error creating client certificate ", err)
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
-	node := request.Node
-	pretty.Println(node)
-	log.Println("check if network exists ", request.Node.Network)
-	networkexists, err := functions.NetworkExists(request.Node.Network)
+	//node := request.Node
+	//pretty.Println(node)
+	log.Println("check if network exists ", node.Network)
+	networkexists, err := functions.NetworkExists(node.Network)
 
 	if err != nil {
 		log.Println("network does not exist error")
@@ -413,14 +430,14 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	network, err := logic.GetNetworkByNode(&request.Node)
+	network, err := logic.GetNetworkByNode(&node)
 	if err != nil {
 		log.Println("failed to get Network")
 		returnErrorResponse(w, r, formatError(err, "internal"))
 		return
 	}
 
-	validKey := logic.IsKeyValid(network.NetID, request.Node.AccessKey)
+	validKey := logic.IsKeyValid(network.NetID, node.AccessKey)
 
 	if !validKey {
 		// Check to see if network will allow manual sign up
@@ -436,7 +453,7 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	newNode, err := logic.CreateNode(&request.Node)
+	newNode, err := logic.CreateNode(&node)
 	if err != nil {
 		log.Println("error creating node")
 		returnErrorResponse(w, r, formatError(err, "internal"))
@@ -459,11 +476,12 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		Peers:       peers,
 		Certificate: *cert,
 		CA:          *ca,
+		Key:         private,
 	}
-	logger.Log(1, r.Header.Get("user"), "created new node", request.Node.Name, "on network", node.Network)
+	logger.Log(1, r.Header.Get("user"), "created new node", node.Name, "on network", node.Network)
 	w.WriteHeader(http.StatusOK)
 	json.NewEncoder(w).Encode(response)
-	runForceServerUpdate(&request.Node)
+	runForceServerUpdate(&node)
 }
 
 // Takes node out of pending state

netclient/config/config.go

@@ -51,6 +51,7 @@ type JoinResponse struct {
 	Peers       []wgtypes.PeerConfig
 	Certificate x509.Certificate
 	CA          x509.Certificate
+	Key         ed25519.PrivateKey
 }
 
 // Write - writes the config of a client to disk

netclient/functions/join.go

@@ -2,8 +2,6 @@ package functions
 
 import (
 	"bytes"
-	"crypto/ed25519"
-	"crypto/rand"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -103,23 +101,23 @@ func JoinNetwork(cfg *config.ClientConfig, privateKey string) error {
 	//if err != nil {
 	//	return err
 	//}
-	public, key, err := ed25519.GenerateKey(rand.Reader)
-	if err != nil {
-		return err
-	}
-	name := tls.NewCName(cfg.Node.Name)
-	csr, err := tls.NewCSR(key, name)
-	if err != nil {
-		return err
-	}
-	request := config.JoinRequest{
-		Node: cfg.Node,
-		Key:  public,
-		CSR:  *csr,
-	}
+	//public, key, err := ed25519.GenerateKey(rand.Reader)
+	//if err != nil {
+	//return err
+	//}
+	//name := tls.NewCName(cfg.Node.Name)
+	//csr, err := tls.NewCSR(key, name)
+	//if err != nil {
+	//	return err
+	//}
+	//request := config.JoinRequest{
+	//	Node: cfg.Node,
+	//	Key:  public,
+	//	CSR:  *csr,
+	//}
 
 	log.Println("calling api ", cfg.Server.API+"/api/nodes/join")
-	response, err := join(request, "https://"+cfg.Server.API+"/api/nodes/join", cfg.Node.AccessKey)
+	response, err := join(cfg.Node, "https://"+cfg.Server.API+"/api/nodes/join", cfg.Node.AccessKey)
 	if err != nil {
 		return fmt.Errorf("error joining network %w", err)
 	}
@@ -239,7 +237,7 @@ func setListenPort(oldListenPort int32, cfg *config.ClientConfig) {
 	}
 }
 
-func join(node config.JoinRequest, url, authorization string) (*config.JoinResponse, error) {
+func join(node models.Node, url, authorization string) (*config.JoinResponse, error) {
 	var request *http.Request
 	var joinResponse config.JoinResponse
 	payload, err := json.Marshal(node)