zishuo/netmaker
1
0
Fork 0
mirror of https://github.com/gravitl/netmaker.git synced 2025-10-30 11:46:28 +08:00
Code Issues Packages Projects Releases Wiki Activity

restructuring continued

Browse Source
This commit is contained in:
0xdcarns
2022-01-10 17:52:21 -05:00
parent c033be41bb
commit 64e7791011
13 changed files with 178 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
controllers/auth_grpc.go
View File

@@ -72,7 +72,7 @@ func grpcAuthorize(ctx context.Context) error {
authToken := authHeader[0]
mac, network, err := logic.VerifyToken(authToken)
nodeID, mac, network, err := logic.VerifyToken(authToken)
if err != nil {
return err
}
@@ -83,9 +83,10 @@ func grpcAuthorize(ctx context.Context) error {
return status.Errorf(codes.Unauthenticated, "Unauthorized. Network does not exist: "+network)
}
emptynode := models.Node{}
node, err := logic.GetNodeByMacAddress(network, mac)
node, err := logic.GetNodeByIDorMacAddress(nodeID, mac, network)
if database.IsEmptyRecord(err) {
if node, err = logic.GetDeletedNodeByMacAddress(network, mac); err == nil {
// == DELETE replace logic after 2 major version updates ==
if node, err = logic.GetDeletedNodeByID(node.ID); err == nil {
if functions.RemoveDeletedNode(node.ID) {
return status.Errorf(codes.Unauthenticated, models.NODE_DELETE)
}
@@ -112,17 +113,18 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
return nil, err
}
macaddress := reqNode.MacAddress
nodeID := reqNode.ID
network := reqNode.Network
password := reqNode.Password
macaddress := reqNode.MacAddress
var result models.NodeAuth
var err error
// err := errors.New("generic server error")
if macaddress == "" {
if nodeID == "" {
//TODO: Set Error response
err = errors.New("missing mac address")
err = errors.New("missing node ID")
return nil, err
} else if password == "" {
err = errors.New("missing password")
@@ -137,7 +139,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
if err = json.Unmarshal([]byte(value), &result); err != nil {
continue // finish going through nodes
}
if result.MacAddress == macaddress && result.Network == network {
if result.ID == nodeID && result.Network == network {
break
}
}
@@ -150,7 +152,7 @@ func (s *NodeServiceServer) Login(ctx context.Context, req *nodepb.Object) (*nod
return nil, err
} else {
//Create a new JWT for the node
tokenString, err := logic.CreateJWT(macaddress, result.Network)
tokenString, err := logic.CreateJWT(result.ID, macaddress, result.Network)
if err != nil {
return nil, err

16
controllers/ext_client.go
View File

@@ -25,11 +25,11 @@ func extClientHandlers(r *mux.Router) {
r.HandleFunc("/api/extclients/{network}/{clientid}/{type}", securityCheck(false, http.HandlerFunc(getExtClientConf))).Methods("GET")
r.HandleFunc("/api/extclients/{network}/{clientid}", securityCheck(false, http.HandlerFunc(updateExtClient))).Methods("PUT")
r.HandleFunc("/api/extclients/{network}/{clientid}", securityCheck(false, http.HandlerFunc(deleteExtClient))).Methods("DELETE")
r.HandleFunc("/api/extclients/{network}/{macaddress}", securityCheck(false, http.HandlerFunc(createExtClient))).Methods("POST")
r.HandleFunc("/api/extclients/{network}/{nodeid}", securityCheck(false, http.HandlerFunc(createExtClient))).Methods("POST")
}
func checkIngressExists(network string, macaddress string) bool {
node, err := logic.GetNodeByMacAddress(network, macaddress)
func checkIngressExists(nodeID string) bool {
node, err := logic.GetNodeByID(nodeID)
if err != nil {
return false
}
@@ -122,7 +122,7 @@ func getExtClientConf(w http.ResponseWriter, r *http.Request) {
return
}
gwnode, err := logic.GetNodeByMacAddress(client.Network, client.IngressGatewayID)
gwnode, err := logic.GetNodeByID(client.IngressGatewayID)
if err != nil {
logger.Log(1, fmt.Sprintf("%s %s %s", r.Header.Get("user"), "Could not retrieve Ingress Gateway Node", client.IngressGatewayID))
returnErrorResponse(w, r, formatError(err, "internal"))
@@ -211,8 +211,8 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
networkName := params["network"]
macaddress := params["macaddress"]
ingressExists := checkIngressExists(networkName, macaddress)
nodeid := params["nodeid"]
ingressExists := checkIngressExists(nodeid)
if !ingressExists {
returnErrorResponse(w, r, formatError(errors.New("ingress does not exist"), "internal"))
return
@@ -220,8 +220,8 @@ func createExtClient(w http.ResponseWriter, r *http.Request) {
var extclient models.ExtClient
extclient.Network = networkName
extclient.IngressGatewayID = macaddress
node, err := logic.GetNodeByMacAddress(networkName, macaddress)
extclient.IngressGatewayID = nodeid
node, err := logic.GetNodeByIDorMacAddress(nodeid, nodeid, networkName)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return

75
controllers/node.go
View File

@@ -19,17 +19,17 @@ func nodeHandlers(r *mux.Router) {
r.HandleFunc("/api/nodes", authorize(false, "user", http.HandlerFunc(getAllNodes))).Methods("GET")
r.HandleFunc("/api/nodes/{network}", authorize(true, "network", http.HandlerFunc(getNetworkNodes))).Methods("GET")
r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
r.HandleFunc("/api/nodes/{network}/{macaddress}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{macaddress}/createrelay", authorize(true, "user", http.HandlerFunc(createRelay))).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{macaddress}/deleterelay", authorize(true, "user", http.HandlerFunc(deleteRelay))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{macaddress}/creategateway", authorize(true, "user", http.HandlerFunc(createEgressGateway))).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{macaddress}/deletegateway", authorize(true, "user", http.HandlerFunc(deleteEgressGateway))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{macaddress}/createingress", securityCheck(false, http.HandlerFunc(createIngressGateway))).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{macaddress}/deleteingress", securityCheck(false, http.HandlerFunc(deleteIngressGateway))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{macaddress}/approve", authorize(true, "user", http.HandlerFunc(uncordonNode))).Methods("POST")
r.HandleFunc("/api/nodes/{network}", createNode).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(getNode))).Methods("GET")
r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(updateNode))).Methods("PUT")
r.HandleFunc("/api/nodes/{network}/{nodeid}", authorize(true, "node", http.HandlerFunc(deleteNode))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{nodeid}/createrelay", authorize(true, "user", http.HandlerFunc(createRelay))).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{nodeid}/deleterelay", authorize(true, "user", http.HandlerFunc(deleteRelay))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{nodeid}/creategateway", authorize(true, "user", http.HandlerFunc(createEgressGateway))).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{nodeid}/deletegateway", authorize(true, "user", http.HandlerFunc(deleteEgressGateway))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{nodeid}/createingress", securityCheck(false, http.HandlerFunc(createIngressGateway))).Methods("POST")
r.HandleFunc("/api/nodes/{network}/{nodeid}/deleteingress", securityCheck(false, http.HandlerFunc(deleteIngressGateway))).Methods("DELETE")
r.HandleFunc("/api/nodes/{network}/{nodeid}/approve", authorize(true, "user", http.HandlerFunc(uncordonNode))).Methods("POST")
// r.HandleFunc("/api/nodes/{network}", createNode).Methods("POST")
r.HandleFunc("/api/nodes/adm/{network}/lastmodified", authorize(true, "network", http.HandlerFunc(getLastModified))).Methods("GET")
r.HandleFunc("/api/nodes/adm/{network}/authenticate", authenticate).Methods("POST")
@@ -78,7 +78,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
if err := json.Unmarshal([]byte(value), &result); err != nil {
continue
}
if result.MacAddress == authRequest.MacAddress && result.IsPending != "yes" && result.Network == networkname {
if (result.ID == authRequest.ID || result.MacAddress == authRequest.MacAddress) && result.IsPending != "yes" && result.Network == networkname {
break
}
}
@@ -97,7 +97,7 @@ func authenticate(response http.ResponseWriter, request *http.Request) {
returnErrorResponse(response, request, errorResponse)
return
} else {
tokenString, _ := logic.CreateJWT(authRequest.MacAddress, result.Network)
tokenString, _ := logic.CreateJWT(authRequest.ID, authRequest.MacAddress, result.Network)
if tokenString == "" {
errorResponse.Code = http.StatusBadRequest
@@ -177,11 +177,11 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
}
var isAuthorized = false
var macaddress = ""
var nodeID = ""
username, networks, isadmin, errN := logic.VerifyUserToken(authToken)
isnetadmin := isadmin
if errN == nil && isadmin {
macaddress = "mastermac"
nodeID = "mastermac"
isAuthorized = true
r.Header.Set("ismasterkey", "yes")
}
@@ -191,7 +191,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
}
}
//The mastermac (login with masterkey from config) can do everything!! May be dangerous.
if macaddress == "mastermac" {
if nodeID == "mastermac" {
isAuthorized = true
r.Header.Set("ismasterkey", "yes")
//for everyone else, there's poor man's RBAC. The "cases" are defined in the routes in the handlers
@@ -201,12 +201,12 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
case "all":
isAuthorized = true
case "nodes":
isAuthorized = (macaddress != "") || isnetadmin
isAuthorized = (nodeID != "") || isnetadmin
case "network":
if isnetadmin {
isAuthorized = true
} else {
node, err := logic.GetNodeByMacAddress(params["network"], macaddress)
node, err := logic.GetNodeByID(nodeID)
if err != nil {
errorResponse = models.ErrorResponse{
Code: http.StatusUnauthorized, Message: "W1R3: Missing Auth Token.",
@@ -220,7 +220,7 @@ func authorize(networkCheck bool, authNetwork string, next http.Handler) http.Ha
if isnetadmin {
isAuthorized = true
} else {
isAuthorized = (macaddress == params["macaddress"])
isAuthorized = (nodeID == params["netid"])
}
case "user":
isAuthorized = true
@@ -315,12 +315,12 @@ func getNode(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
node, err := logic.GetNode(params["macaddress"], params["network"])
node, err := logic.GetNodeByID(params["nodeid"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
logger.Log(2, r.Header.Get("user"), "fetched node", params["macaddress"])
logger.Log(2, r.Header.Get("user"), "fetched node", params["nodeid"])
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
}
@@ -414,7 +414,7 @@ func createNode(w http.ResponseWriter, r *http.Request) {
func uncordonNode(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
w.Header().Set("Content-Type", "application/json")
node, err := logic.UncordonNode(params["network"], params["macaddress"])
node, err := logic.UncordonNode(params["nodeid"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -434,7 +434,7 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
return
}
gateway.NetID = params["network"]
gateway.NodeID = params["macaddress"]
gateway.NodeID = params["nodeid"]
node, err := logic.CreateEgressGateway(gateway)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
@@ -448,14 +448,14 @@ func createEgressGateway(w http.ResponseWriter, r *http.Request) {
func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var params = mux.Vars(r)
nodeMac := params["macaddress"]
nodeid := params["nodeid"]
netid := params["network"]
node, err := logic.DeleteEgressGateway(netid, nodeMac)
node, err := logic.DeleteEgressGateway(netid, nodeid)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeMac, "on network", netid)
logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
}
@@ -465,14 +465,14 @@ func deleteEgressGateway(w http.ResponseWriter, r *http.Request) {
func createIngressGateway(w http.ResponseWriter, r *http.Request) {
var params = mux.Vars(r)
w.Header().Set("Content-Type", "application/json")
nodeMac := params["macaddress"]
nodeid := params["nodeid"]
netid := params["network"]
node, err := logic.CreateIngressGateway(netid, nodeMac)
node, err := logic.CreateIngressGateway(netid, nodeid)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
logger.Log(1, r.Header.Get("user"), "created ingress gateway on node", nodeMac, "on network", netid)
logger.Log(1, r.Header.Get("user"), "created ingress gateway on node", nodeid, "on network", netid)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
}
@@ -480,13 +480,13 @@ func createIngressGateway(w http.ResponseWriter, r *http.Request) {
func deleteIngressGateway(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var params = mux.Vars(r)
nodeMac := params["macaddress"]
node, err := logic.DeleteIngressGateway(params["network"], nodeMac)
nodeid := params["nodeid"]
node, err := logic.DeleteIngressGateway(params["network"], nodeid)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
logger.Log(1, r.Header.Get("user"), "deleted ingress gateway", nodeMac)
logger.Log(1, r.Header.Get("user"), "deleted ingress gateway", nodeid)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
}
@@ -498,7 +498,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
var node models.Node
//start here
node, err := logic.GetNodeByMacAddress(params["network"], params["macaddress"])
node, err := logic.GetNodeByID(params["nodeid"])
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
@@ -560,17 +560,18 @@ func deleteNode(w http.ResponseWriter, r *http.Request) {
// get params
var params = mux.Vars(r)
var node, err = logic.GetNode(params["macaddress"], params["network"])
var nodeid = params["nodeid"]
var node, err = logic.GetNodeByID(nodeid)
if err != nil {
returnErrorResponse(w, r, formatError(err, "badrequest"))
return
}
err = logic.DeleteNode(&node, false)
err = logic.DeleteNodeByMacAddress(&node, false)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
logger.Log(1, r.Header.Get("user"), "Deleted node", params["macaddress"], "from network", params["network"])
returnSuccessResponse(w, r, params["macaddress"]+" deleted.")
logger.Log(1, r.Header.Get("user"), "Deleted node", nodeid, "from network", params["network"])
returnSuccessResponse(w, r, nodeid+" deleted.")
}

22
controllers/node_grpc.go
View File

@@ -21,15 +21,21 @@ type NodeServiceServer struct {
// NodeServiceServer.ReadNode - reads node and responds with gRPC
func (s *NodeServiceServer) ReadNode(ctx context.Context, req *nodepb.Object) (*nodepb.Object, error) {
// convert string id (from proto) to mongoDB ObjectId
macAndNetwork := strings.Split(req.Data, "###")
if len(macAndNetwork) != 2 {
return nil, errors.New("could not read node, invalid node id given")
var err error
var node models.Node
var macAndNetwork = make([]string, 2)
if strings.Contains(req.Data, "###") {
macAndNetwork = strings.Split(req.Data, "###")
if len(macAndNetwork) != 2 {
return nil, errors.New("could not read node, invalid node id given")
}
}
node, err := logic.GetNode(macAndNetwork[0], macAndNetwork[1])
node, err = logic.GetNodeByIDorMacAddress(req.Data, macAndNetwork[0], macAndNetwork[1])
if err != nil {
return nil, err
}
node.NetworkSettings, err = logic.GetNetworkSettings(node.Network)
if err != nil {
return nil, err
@@ -101,10 +107,8 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.Object)
if err := json.Unmarshal([]byte(req.GetData()), &newnode); err != nil {
return nil, err
}
macaddress := newnode.MacAddress
networkName := newnode.Network
node, err := logic.GetNodeByMacAddress(networkName, macaddress)
node, err := logic.GetNodeByIDorMacAddress(newnode.ID, newnode.MacAddress, newnode.Network)
if err != nil {
return nil, err
}
@@ -140,7 +144,7 @@ func (s *NodeServiceServer) DeleteNode(ctx context.Context, req *nodepb.Object)
return nil, errors.New("node not found")
}
var node, err = logic.GetNode(nodeInfo[0], nodeInfo[1])
err = logic.DeleteNode(&node, true)
err = logic.DeleteNodeByMacAddress(&node, true)
if err != nil {
return nil, err
}

13
controllers/node_test.go
View File

@@ -105,18 +105,13 @@ func TestUncordonNode(t *testing.T) {
deleteAllNetworks()
createNet()
node := createTestNode()
t.Run("BadNet", func(t *testing.T) {
resp, err := logic.UncordonNode("badnet", node.MacAddress)
assert.Equal(t, models.Node{}, resp)
assert.EqualError(t, err, "no result found")
})
t.Run("BadMac", func(t *testing.T) {
resp, err := logic.UncordonNode("skynet", "01:02:03")
t.Run("BadID", func(t *testing.T) {
resp, err := logic.UncordonNode("blahblah")
assert.Equal(t, models.Node{}, resp)
assert.EqualError(t, err, "no result found")
})
t.Run("Success", func(t *testing.T) {
resp, err := logic.UncordonNode("skynet", node.MacAddress)
resp, err := logic.UncordonNode(node.ID)
assert.Nil(t, err)
assert.Equal(t, "no", resp.IsPending)
})
@@ -147,7 +142,7 @@ func TestValidateEgressGateway(t *testing.T) {
func deleteAllNodes() {
nodes, _ := logic.GetAllNodes()
for _, node := range nodes {
logic.DeleteNode(&node, true)
logic.DeleteNodeByMacAddress(&node, true)
}
}

8
controllers/relay.go
View File

@@ -20,7 +20,7 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
return
}
relay.NetID = params["network"]
relay.NodeID = params["macaddress"]
relay.NodeID = params["nodeid"]
node, err := logic.CreateRelay(relay)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
@@ -34,14 +34,14 @@ func createRelay(w http.ResponseWriter, r *http.Request) {
func deleteRelay(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var params = mux.Vars(r)
nodeMac := params["macaddress"]
nodeid := params["nodeid"]
netid := params["network"]
node, err := logic.DeleteRelay(netid, nodeMac)
node, err := logic.DeleteRelay(netid, nodeid)
if err != nil {
returnErrorResponse(w, r, formatError(err, "internal"))
return
}
logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeMac, "on network", netid)
logger.Log(1, r.Header.Get("user"), "deleted egress gateway", nodeid, "on network", netid)
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(node)
}