shrink header to inc MTU to 1416

config/config.go

@@ -37,11 +37,18 @@ type SuperConfig struct {
 	ListenPort              int
 	LogLevel                LoggerInfo
 	RePushConfigInterval    float64
-	StatePassword           string
+	Passwords               Passwords
 	GraphRecalculateSetting GraphRecalculateSetting
+	EdgeTemplate            string
 	Peers                   []SuperPeerInfo
 }
 
+type Passwords struct {
+	ShowState string
+	AddPeer   string
+	DelPeer   string
+}
+
 type InterfaceConf struct {
 	Itype         string
 	Name          string

device/cookie.go

@@ -11,6 +11,7 @@ import (
 	"sync"
 	"time"
 
+	"github.com/KusakabeSi/EtherGuardVPN/path"
 	"golang.org/x/crypto/blake2s"
 	"golang.org/x/crypto/chacha20poly1305"
 )
@@ -154,7 +155,7 @@ func (st *CookieChecker) CreateReply(
 	smac1 := smac2 - blake2s.Size128
 
 	reply := new(MessageCookieReply)
-	reply.Type = MessageCookieReplyType
+	reply.Type = path.MessageCookieReplyType
 	reply.Receiver = recv
 
 	_, err := rand.Read(reply.Nonce[:])

device/device.go

@@ -6,6 +6,7 @@
 package device
 
 import (
+	"bytes"
 	"encoding/base64"
 	"errors"
 	"runtime"
@@ -392,7 +393,7 @@ func (device *Device) LookupPeerIDAtConfig(pk NoisePublicKey) (ID config.Vertex,
 			return 0, errors.New("Superconfig is nil")
 		}
 		peerlist = device.SuperConfig.Peers
-		pkstr := PubKey2Str(pk)
+		pkstr := pk.ToString()
 		for _, peerinfo := range peerlist {
 			if peerinfo.PubKey == pkstr {
 				return peerinfo.NodeID, nil
@@ -404,7 +405,7 @@ func (device *Device) LookupPeerIDAtConfig(pk NoisePublicKey) (ID config.Vertex,
 			return 0, errors.New("EdgeConfig is nil")
 		}
 		peerlist = device.EdgeConfig.Peers
-		pkstr := PubKey2Str(pk)
+		pkstr := pk.ToString()
 		for _, peerinfo := range peerlist {
 			if peerinfo.PubKey == pkstr {
 				return peerinfo.NodeID, nil
@@ -429,34 +430,51 @@ func (device *Device) LookupPeerByStr(pks string) *Peer {
 	return device.LookupPeer(pk)
 }
 
-func PubKey2Str(pk NoisePublicKey) (result string) {
+func (pk *NoisePublicKey) ToString() string {
-	result = string(base64.StdEncoding.EncodeToString(pk[:]))
+	if bytes.Equal(pk[:], make([]byte, len(pk))) {
-	return
+		return ""
+	}
+	return string(base64.StdEncoding.EncodeToString(pk[:]))
 }
 
-func PriKey2Str(pk NoisePrivateKey) (result string) {
+func (pk *NoisePrivateKey) ToString() (result string) {
-	result = string(base64.StdEncoding.EncodeToString(pk[:]))
+	if bytes.Equal(pk[:], make([]byte, len(pk))) {
-	return
+		return ""
+	}
+	return string(base64.StdEncoding.EncodeToString(pk[:]))
 }
-func PSKeyStr(pk NoisePresharedKey) (result string) {
+func (pk *NoisePresharedKey) ToString() (result string) {
-	result = string(base64.StdEncoding.EncodeToString(pk[:]))
+	if bytes.Equal(pk[:], make([]byte, len(pk))) {
-	return
+		return ""
+	}
+	return string(base64.StdEncoding.EncodeToString(pk[:]))
 }
 
-func Str2PubKey(k string) (pk NoisePublicKey) {
+func Str2PubKey(k string) (pk NoisePublicKey, err error) {
-	sk_slice, _ := base64.StdEncoding.DecodeString(k)
+	if k == "" {
+		err = errors.New("Empty public key string")
+		return
+	}
+	sk_slice, err := base64.StdEncoding.DecodeString(k)
 	copy(pk[:], sk_slice)
 	return
 }
 
-func Str2PriKey(k string) (pk NoisePrivateKey) {
+func Str2PriKey(k string) (pk NoisePrivateKey, err error) {
-	sk_slice, _ := base64.StdEncoding.DecodeString(k)
+	if k == "" {
+		err = errors.New("Empty private key string")
+		return
+	}
+	sk_slice, err := base64.StdEncoding.DecodeString(k)
 	copy(pk[:], sk_slice)
 	return
 }
 
-func Str2PSKey(k string) (pk NoisePresharedKey) {
+func Str2PSKey(k string) (pk NoisePresharedKey, err error) {
-	sk_slice, _ := base64.StdEncoding.DecodeString(k)
+	if k == "" {
+		return
+	}
+	sk_slice, err := base64.StdEncoding.DecodeString(k)
 	copy(pk[:], sk_slice)
 	return
 }

device/noise-protocol.go

@@ -15,6 +15,7 @@ import (
 	"golang.org/x/crypto/chacha20poly1305"
 	"golang.org/x/crypto/poly1305"
 
+	"github.com/KusakabeSi/EtherGuardVPN/path"
 	"github.com/KusakabeSi/EtherGuardVPN/tai64n"
 )
 
@@ -53,26 +54,19 @@ const (
 )
 
 const (
-	MessageInitiationType  = 1
+	MessageInitiationSize      = 145                                           // size of handshake initiation message
-	MessageResponseType    = 2
+	MessageResponseSize        = 89                                            // size of response message
-	MessageCookieReplyType = 3
+	MessageCookieReplySize     = 61                                            // size of cookie reply message
-	MessageTransportType   = 4
+	MessageTransportHeaderSize = 13                                            // size of data preceding content in transport message
-)
-
-const (
-	MessageInitiationSize      = 148                                           // size of handshake initiation message
-	MessageResponseSize        = 92                                            // size of response message
-	MessageCookieReplySize     = 64                                            // size of cookie reply message
-	MessageTransportHeaderSize = 16                                            // size of data preceding content in transport message
 	MessageTransportSize       = MessageTransportHeaderSize + poly1305.TagSize // size of empty transport
 	MessageKeepaliveSize       = MessageTransportSize                          // size of keepalive
 	MessageHandshakeSize       = MessageInitiationSize                         // size of largest handshake related message
 )
 
 const (
-	MessageTransportOffsetReceiver = 4
+	MessageTransportOffsetReceiver = 1
-	MessageTransportOffsetCounter  = 8
+	MessageTransportOffsetCounter  = 5
-	MessageTransportOffsetContent  = 16
+	MessageTransportOffsetContent  = 13
 )
 
 /* Type is an 8-bit field, followed by 3 nul bytes,
@@ -82,7 +76,7 @@ const (
  */
 
 type MessageInitiation struct {
-	Type      uint32
+	Type      path.Usage
 	Sender    uint32
 	Ephemeral NoisePublicKey
 	Static    [NoisePublicKeySize + poly1305.TagSize]byte
@@ -92,7 +86,7 @@ type MessageInitiation struct {
 }
 
 type MessageResponse struct {
-	Type      uint32
+	Type      path.Usage
 	Sender    uint32
 	Receiver  uint32
 	Ephemeral NoisePublicKey
@@ -102,14 +96,14 @@ type MessageResponse struct {
 }
 
 type MessageTransport struct {
-	Type     uint32
+	Type     path.Usage
 	Receiver uint32
 	Counter  uint64
 	Content  []byte
 }
 
 type MessageCookieReply struct {
-	Type     uint32
+	Type     path.Usage
 	Receiver uint32
 	Nonce    [chacha20poly1305.NonceSizeX]byte
 	Cookie   [blake2s.Size128 + poly1305.TagSize]byte
@@ -196,7 +190,7 @@ func (device *Device) CreateMessageInitiation(peer *Peer) (*MessageInitiation, e
 	handshake.mixHash(handshake.remoteStatic[:])
 
 	msg := MessageInitiation{
-		Type:      MessageInitiationType,
+		Type:      path.MessageInitiationType,
 		Ephemeral: handshake.localEphemeral.publicKey(),
 	}
 
@@ -252,7 +246,7 @@ func (device *Device) ConsumeMessageInitiation(msg *MessageInitiation) *Peer {
 		chainKey [blake2s.Size]byte
 	)
 
-	if msg.Type != MessageInitiationType {
+	if msg.Type != path.MessageInitiationType {
 		return nil
 	}
 
@@ -370,7 +364,7 @@ func (device *Device) CreateMessageResponse(peer *Peer) (*MessageResponse, error
 	}
 
 	var msg MessageResponse
-	msg.Type = MessageResponseType
+	msg.Type = path.MessageResponseType
 	msg.Sender = handshake.localIndex
 	msg.Receiver = handshake.remoteIndex
 
@@ -418,7 +412,7 @@ func (device *Device) CreateMessageResponse(peer *Peer) (*MessageResponse, error
 }
 
 func (device *Device) ConsumeMessageResponse(msg *MessageResponse) *Peer {
-	if msg.Type != MessageResponseType {
+	if msg.Type != path.MessageResponseType {
 		return nil
 	}
 

device/peer.go

@@ -8,7 +8,6 @@ package device
 import (
 	"bytes"
 	"container/list"
-	"encoding/base64"
 	"errors"
 	"fmt"
 	"io/ioutil"
@@ -18,6 +17,7 @@ import (
 
 	"github.com/KusakabeSi/EtherGuardVPN/config"
 	"github.com/KusakabeSi/EtherGuardVPN/conn"
+	orderedmap "github.com/KusakabeSi/EtherGuardVPN/orderdmap"
 	"gopkg.in/yaml.v2"
 )
 
@@ -28,7 +28,7 @@ type Peer struct {
 	handshake        Handshake
 	device           *Device
 	endpoint         conn.Endpoint
-	endpoint_trylist sync.Map //map[string]time.Time
+	endpoint_trylist orderedmap.OrderedMap //map[string]time.Time
 	LastPingReceived time.Time
 	stopping         sync.WaitGroup // routines pending stop
 
@@ -95,7 +95,7 @@ func (device *Device) NewPeer(pk NoisePublicKey, id config.Vertex) (*Peer, error
 
 	// create peer
 	if device.LogLevel.LogControl {
-		fmt.Println("Control: Create peer with ID : " + id.ToString() + " and PubKey:" + base64.StdEncoding.EncodeToString(pk[:]))
+		fmt.Println("Control: Create peer with ID : " + id.ToString() + " and PubKey:" + pk.ToString())
 	}
 	peer := new(Peer)
 	peer.Lock()
@@ -103,6 +103,7 @@ func (device *Device) NewPeer(pk NoisePublicKey, id config.Vertex) (*Peer, error
 
 	peer.cookieGenerator.Init(pk)
 	peer.device = device
+	peer.endpoint_trylist = orderedmap.New()
 	peer.queue.outbound = newAutodrainingOutboundQueue(device)
 	peer.queue.inbound = newAutodrainingInboundQueue(device)
 	peer.queue.staged = make(chan *QueueOutboundElement, QueueStagedSize)
@@ -342,8 +343,8 @@ func (device *Device) SaveToConfig(peer *Peer, endpoint conn.Endpoint) {
 
 	url := endpoint.DstToString()
 	foundInFile := false
-	pubkeystr := PubKey2Str(peer.handshake.remoteStatic)
+	pubkeystr := peer.handshake.remoteStatic.ToString()
-	pskstr := PSKeyStr(peer.handshake.presharedKey)
+	pskstr := peer.handshake.presharedKey.ToString()
 	if bytes.Equal(peer.handshake.presharedKey[:], make([]byte, 32)) {
 		pskstr = ""
 	}

device/receive.go

@@ -25,13 +25,14 @@ import (
 )
 
 type QueueHandshakeElement struct {
-	msgType  uint32
+	msgType  path.Usage
 	packet   []byte
 	endpoint conn.Endpoint
 	buffer   *[MaxMessageSize]byte
 }
 
 type QueueInboundElement struct {
+	Type path.Usage
 	sync.Mutex
 	buffer   *[MaxMessageSize]byte
 	packet   []byte
@@ -122,15 +123,19 @@ func (device *Device) RoutineReceiveIncoming(recv conn.ReceiveFunc) {
 		// check size of packet
 
 		packet := buffer[:size]
-		msgType := binary.LittleEndian.Uint32(packet[:4])
+		msgType := path.Usage(packet[0])
+		msgType_wg := msgType
+		if msgType >= path.MessageTransportType {
+			msgType_wg = path.MessageTransportType
+		}
 
 		var okay bool
 
-		switch msgType {
+		switch msgType_wg {
 
 		// check if transport
 
-		case MessageTransportType:
+		case path.MessageTransportType:
 
 			// check size
 
@@ -158,6 +163,7 @@ func (device *Device) RoutineReceiveIncoming(recv conn.ReceiveFunc) {
 			// create work element
 			peer := value.peer
 			elem := device.GetInboundElement()
+			elem.Type = msgType
 			elem.packet = packet
 			elem.buffer = buffer
 			elem.keypair = keypair
@@ -178,13 +184,13 @@ func (device *Device) RoutineReceiveIncoming(recv conn.ReceiveFunc) {
 
 		// otherwise it is a fixed size & handshake related packet
 
-		case MessageInitiationType:
+		case path.MessageInitiationType:
 			okay = len(packet) == MessageInitiationSize
 
-		case MessageResponseType:
+		case path.MessageResponseType:
 			okay = len(packet) == MessageResponseSize
 
-		case MessageCookieReplyType:
+		case path.MessageCookieReplyType:
 			okay = len(packet) == MessageCookieReplySize
 
 		default:
@@ -250,7 +256,7 @@ func (device *Device) RoutineHandshake(id int) {
 
 		switch elem.msgType {
 
-		case MessageCookieReplyType:
+		case path.MessageCookieReplyType:
 
 			// unmarshal packet
 
@@ -281,7 +287,7 @@ func (device *Device) RoutineHandshake(id int) {
 
 			goto skip
 
-		case MessageInitiationType, MessageResponseType:
+		case path.MessageInitiationType, path.MessageResponseType:
 
 			// check mac fields and maybe ratelimit
 
@@ -316,7 +322,7 @@ func (device *Device) RoutineHandshake(id int) {
 		// handle handshake initiation/response content
 
 		switch elem.msgType {
-		case MessageInitiationType:
+		case path.MessageInitiationType:
 
 			// unmarshal
 
@@ -349,7 +355,7 @@ func (device *Device) RoutineHandshake(id int) {
 
 			peer.SendHandshakeResponse()
 
-		case MessageResponseType:
+		case path.MessageResponseType:
 
 			// unmarshal
 
@@ -454,7 +460,7 @@ func (peer *Peer) RoutineSequentialReceiver() {
 		src_nodeID = EgHeader.GetSrc()
 		dst_nodeID = EgHeader.GetDst()
 		elem.packet = elem.packet[:EgHeader.GetPacketLength()+path.EgHeaderLen] // EG header + true packet
-		packet_type = EgHeader.GetUsage()
+		packet_type = elem.Type
 
 		if device.IsSuperNode {
 			peer.LastPingReceived = time.Now()
@@ -506,12 +512,12 @@ func (peer *Peer) RoutineSequentialReceiver() {
 			} else {
 				EgHeader.SetTTL(l2ttl - 1)
 				if dst_nodeID == config.Boardcast { //Regular transfer algorithm
-					device.TransitBoardcastPacket(src_nodeID, peer.ID, elem.packet, MessageTransportOffsetContent)
+					device.TransitBoardcastPacket(src_nodeID, peer.ID, elem.Type, elem.packet, MessageTransportOffsetContent)
 				} else if dst_nodeID == config.ControlMessage { // Control Message will try send to every know node regardless the connectivity
 					skip_list := make(map[config.Vertex]bool)
 					skip_list[src_nodeID] = true //Don't send to conimg peer and source peer
 					skip_list[peer.ID] = true
-					device.SpreadPacket(skip_list, elem.packet, MessageTransportOffsetContent)
+					device.SpreadPacket(skip_list, elem.Type, elem.packet, MessageTransportOffsetContent)
 
 				} else {
 					next_id := device.graph.Next(device.ID, dst_nodeID)
@@ -520,7 +526,7 @@ func (peer *Peer) RoutineSequentialReceiver() {
 						if device.LogLevel.LogTransit {
 							fmt.Printf("Transit: Transfer packet from %d through %d to %d\n", peer.ID, device.ID, peer_out.ID)
 						}
-						device.SendPacket(peer_out, elem.packet, MessageTransportOffsetContent)
+						device.SendPacket(peer_out, elem.Type, elem.packet, MessageTransportOffsetContent)
 					}
 				}
 			}

device/receivesendproc.go

@@ -2,7 +2,6 @@ package device
 
 import (
 	"bytes"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -17,7 +16,7 @@ import (
 	"github.com/KusakabeSi/EtherGuardVPN/path"
 )
 
-func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
+func (device *Device) SendPacket(peer *Peer, usage path.Usage, packet []byte, offset int) {
 	if peer == nil {
 		return
 	} else if peer.endpoint == nil {
@@ -25,16 +24,15 @@ func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
 	}
 	if device.LogLevel.LogNormal {
 		EgHeader, _ := path.NewEgHeader(packet[:path.EgHeaderLen])
-		if EgHeader.GetUsage() == path.NornalPacket {
+		if usage == path.NornalPacket {
 			dst_nodeID := EgHeader.GetDst()
 			fmt.Println("Normal: Send Normal packet To:" + peer.GetEndpointDstStr() + " SrcID:" + device.ID.ToString() + " DstID:" + dst_nodeID.ToString() + " Len:" + strconv.Itoa(len(packet)))
 		}
 	}
 	if device.LogLevel.LogControl {
-		EgHeader, _ := path.NewEgHeader(packet[:path.EgHeaderLen])
+		if usage != path.NornalPacket {
-		if EgHeader.GetUsage() != path.NornalPacket {
 			if peer.GetEndpointDstStr() != "" {
-				fmt.Println("Control: Send To:" + peer.GetEndpointDstStr() + " " + device.sprint_received(EgHeader.GetUsage(), packet[path.EgHeaderLen:]))
+				fmt.Println("Control: Send To:" + peer.GetEndpointDstStr() + " " + device.sprint_received(usage, packet[path.EgHeaderLen:]))
 			}
 		}
 	}
@@ -42,6 +40,7 @@ func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
 	var elem *QueueOutboundElement
 	elem = device.NewOutboundElement()
 	copy(elem.buffer[offset:offset+len(packet)], packet)
+	elem.Type = usage
 	elem.packet = elem.buffer[offset : offset+len(packet)]
 	if peer.isRunning.Get() {
 		peer.StagePacket(elem)
@@ -50,7 +49,7 @@ func (device *Device) SendPacket(peer *Peer, packet []byte, offset int) {
 	}
 }
 
-func (device *Device) BoardcastPacket(skip_list map[config.Vertex]bool, packet []byte, offset int) { // Send packet to all connected peers
+func (device *Device) BoardcastPacket(skip_list map[config.Vertex]bool, usage path.Usage, packet []byte, offset int) { // Send packet to all connected peers
 	send_list := device.graph.GetBoardcastList(device.ID)
 	for node_id, _ := range skip_list {
 		send_list[node_id] = false
@@ -58,13 +57,13 @@ func (device *Device) BoardcastPacket(skip_list map[config.Vertex]bool, packet [
 	device.peers.RLock()
 	for node_id, should_send := range send_list {
 		if should_send {
-			device.SendPacket(device.peers.IDMap[node_id], packet, offset)
+			device.SendPacket(device.peers.IDMap[node_id], usage, packet, offset)
 		}
 	}
 	device.peers.RUnlock()
 }
 
-func (device *Device) SpreadPacket(skip_list map[config.Vertex]bool, packet []byte, offset int) { // Send packet to all peers no matter it is alive
+func (device *Device) SpreadPacket(skip_list map[config.Vertex]bool, usage path.Usage, packet []byte, offset int) { // Send packet to all peers no matter it is alive
 	device.peers.RLock()
 	for peer_id, peer_out := range device.peers.IDMap {
 		if _, ok := skip_list[peer_id]; ok {
@@ -73,12 +72,12 @@ func (device *Device) SpreadPacket(skip_list map[config.Vertex]bool, packet []by
 			}
 			continue
 		}
-		device.SendPacket(peer_out, packet, MessageTransportOffsetContent)
+		device.SendPacket(peer_out, usage, packet, MessageTransportOffsetContent)
 	}
 	device.peers.RUnlock()
 }
 
-func (device *Device) TransitBoardcastPacket(src_nodeID config.Vertex, in_id config.Vertex, packet []byte, offset int) {
+func (device *Device) TransitBoardcastPacket(src_nodeID config.Vertex, in_id config.Vertex, usage path.Usage, packet []byte, offset int) {
 	node_boardcast_list := device.graph.GetBoardcastThroughList(device.ID, in_id, src_nodeID)
 	device.peers.RLock()
 	for peer_id := range node_boardcast_list {
@@ -86,19 +85,19 @@ func (device *Device) TransitBoardcastPacket(src_nodeID config.Vertex, in_id con
 		if device.LogLevel.LogTransit {
 			fmt.Printf("Transit: Transfer packet from %d through %d to %d\n", in_id, device.ID, peer_out.ID)
 		}
-		device.SendPacket(peer_out, packet, offset)
+		device.SendPacket(peer_out, usage, packet, offset)
 	}
 	device.peers.RUnlock()
 }
 
-func (device *Device) Send2Super(packet []byte, offset int) {
+func (device *Device) Send2Super(usage path.Usage, packet []byte, offset int) {
 	device.peers.RLock()
 	if device.DRoute.SuperNode.UseSuperNode {
 		for _, peer_out := range device.peers.SuperPeer {
 			/*if device.LogTransit {
 				fmt.Printf("Send to supernode %s\n", peer_out.endpoint.DstToString())
 			}*/
-			device.SendPacket(peer_out, packet, offset)
+			device.SendPacket(peer_out, usage, packet, offset)
 		}
 	}
 	device.peers.RUnlock()
@@ -236,11 +235,10 @@ func (device *Device) server_process_RegisterMsg(peer *Peer, content path.Regist
 		header, err := path.NewEgHeader(buf[:path.EgHeaderLen])
 		header.SetSrc(device.ID)
 		header.SetTTL(device.DefaultTTL)
-		header.SetUsage(path.UpdateError)
 		header.SetPacketLength(uint16(len(body)))
 		copy(buf[path.EgHeaderLen:], body)
 		header.SetDst(peer.ID)
-		device.SendPacket(peer, buf, MessageTransportOffsetContent)
+		device.SendPacket(peer, path.UpdateError, buf, MessageTransportOffsetContent)
 		return nil
 	}
 	device.Event_server_register <- content
@@ -270,16 +268,15 @@ func (device *Device) process_ping(peer *Peer, content path.PingMsg) error {
 	header, err := path.NewEgHeader(buf[:path.EgHeaderLen])
 	header.SetSrc(device.ID)
 	header.SetTTL(device.DefaultTTL)
-	header.SetUsage(path.PongPacket)
 	header.SetPacketLength(uint16(len(body)))
 	copy(buf[path.EgHeaderLen:], body)
 	if device.DRoute.SuperNode.UseSuperNode {
 		header.SetDst(config.SuperNodeMessage)
-		device.Send2Super(buf, MessageTransportOffsetContent)
+		device.Send2Super(path.PongPacket, buf, MessageTransportOffsetContent)
 	}
 	if device.DRoute.P2P.UseP2P {
 		header.SetDst(config.ControlMessage)
-		device.SpreadPacket(make(map[config.Vertex]bool), buf, MessageTransportOffsetContent)
+		device.SpreadPacket(make(map[config.Vertex]bool), path.PongPacket, buf, MessageTransportOffsetContent)
 	}
 	return nil
 }
@@ -301,10 +298,9 @@ func (device *Device) process_pong(peer *Peer, content path.PongMsg) error {
 			header, err := path.NewEgHeader(buf[:path.EgHeaderLen])
 			header.SetSrc(device.ID)
 			header.SetTTL(device.DefaultTTL)
-			header.SetUsage(path.QueryPeer)
 			header.SetPacketLength(uint16(len(body)))
 			copy(buf[path.EgHeaderLen:], body)
-			device.SendPacket(peer, buf, MessageTransportOffsetContent)
+			device.SendPacket(peer, path.QueryPeer, buf, MessageTransportOffsetContent)
 		}
 	}
 	return nil
@@ -327,7 +323,7 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
 			return nil
 		}
 
-		downloadurl := device.DRoute.SuperNode.APIUrl + "/peerinfo?PubKey=" + url.QueryEscape(PubKey2Str(device.staticIdentity.publicKey)) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
+		downloadurl := device.DRoute.SuperNode.APIUrl + "/peerinfo?PubKey=" + url.QueryEscape(device.staticIdentity.publicKey.ToString()) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
 		if device.LogLevel.LogControl {
 			fmt.Println("Control: Download peerinfo from :" + downloadurl)
 		}
@@ -353,11 +349,33 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
 			return err
 		}
 
+		for nodeID, thepeer := range device.peers.IDMap {
+			pk := thepeer.handshake.remoteStatic
+			psk := thepeer.handshake.presharedKey
+			if val, ok := peer_infos[pk.ToString()]; ok {
+				if val.NodeID != nodeID {
+					device.RemovePeer(pk)
+					continue
+				} else if val.PSKey != psk.ToString() {
+					device.RemovePeer(pk)
+					continue
+				}
+			} else {
+				device.RemovePeer(pk)
+				continue
+			}
+
+		}
+
 		for pubkey, peerinfo := range peer_infos {
 			if len(peerinfo.Connurl) == 0 {
 				return nil
 			}
-			sk := Str2PubKey(pubkey)
+			sk, err := Str2PubKey(pubkey)
+			if err != nil {
+				device.log.Errorf("Error decode base64:", err)
+				return err
+			}
 			if bytes.Equal(sk[:], device.staticIdentity.publicKey[:]) {
 				continue
 			}
@@ -375,7 +393,11 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
 				device.NewPeer(sk, peerinfo.NodeID)
 				thepeer = device.LookupPeer(sk)
 				if peerinfo.PSKey != "" {
-					pk := Str2PSKey(peerinfo.PSKey)
+					pk, err := Str2PSKey(peerinfo.PSKey)
+					if err != nil {
+						device.log.Errorf("Error decode base64:", err)
+						return err
+					}
 					thepeer.handshake.presharedKey = pk
 				}
 			}
@@ -383,7 +405,9 @@ func (device *Device) process_UpdatePeerMsg(peer *Peer, content path.UpdatePeerM
 			if thepeer.LastPingReceived.Add(path.S2TD(device.DRoute.P2P.PeerAliveTimeout)).Before(time.Now()) {
 				//Peer died, try to switch to this new endpoint
 				for url, _ := range peerinfo.Connurl {
-					thepeer.endpoint_trylist.Store(url, time.Time{}) //another gorouting will process it
+					thepeer.Lock()
+					thepeer.endpoint_trylist.Set(url, time.Time{}) //another gorouting will process it
+					thepeer.Unlock()
 					send_signal = true
 				}
 			}
@@ -415,7 +439,7 @@ func (device *Device) process_UpdateNhTableMsg(peer *Peer, content path.UpdateNh
 		if bytes.Equal(device.graph.NhTableHash[:], content.State_hash[:]) {
 			return nil
 		}
-		downloadurl := device.DRoute.SuperNode.APIUrl + "/nhtable?PubKey=" + url.QueryEscape(PubKey2Str(device.staticIdentity.publicKey)) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
+		downloadurl := device.DRoute.SuperNode.APIUrl + "/nhtable?PubKey=" + url.QueryEscape(device.staticIdentity.publicKey.ToString()) + "&State=" + url.QueryEscape(string(content.State_hash[:]))
 		if device.LogLevel.LogControl {
 			fmt.Println("Control: Download NhTable from :" + downloadurl)
 		}
@@ -471,37 +495,51 @@ func (device *Device) RoutineSetEndpoint() {
 		for _, thepeer := range device.peers.IDMap {
 			if thepeer.LastPingReceived.Add(path.S2TD(device.DRoute.P2P.PeerAliveTimeout)).After(time.Now()) {
 				//Peer alives
-				thepeer.endpoint_trylist.Range(func(key, value interface{}) bool {
+				thepeer.Lock()
+				for _, key := range thepeer.endpoint_trylist.Keys() { // delete whole endpoint_trylist
 					thepeer.endpoint_trylist.Delete(key)
-					return true
+				}
-				})
+				thepeer.Unlock()
 			} else {
-				thepeer.endpoint_trylist.Range(func(key interface{}, value interface{}) bool {
+				thepeer.RLock()
-					url := key.(string)
+				trylist := thepeer.endpoint_trylist.Keys()
-					trytime := value.(time.Time)
+				thepeer.RUnlock()
-					if trytime.Sub(time.Time{}) != time.Duration(0) && time.Now().Sub(trytime) > path.S2TD(device.DRoute.ConnTimeOut) {
+				for _, key := range trylist { // try next endpoint
+					connurl := key
+					thepeer.RLock()
+					val, hasval := thepeer.endpoint_trylist.Get(key)
+					thepeer.RUnlock()
+					if !hasval {
+						continue
+					}
+					trytime := val.(time.Time)
+					if trytime.Sub(time.Time{}) != time.Duration(0) && time.Now().Sub(trytime) > path.S2TD(device.DRoute.ConnTimeOut) { // tried before, but no response
+						thepeer.Lock()
 						thepeer.endpoint_trylist.Delete(key)
+						thepeer.Unlock()
 					} else {
-						endpoint, err := device.Bind().ParseEndpoint(url) //trying to bind first url in the list and wait device.DRoute.P2P.PeerAliveTimeout seconds
+						endpoint, err := device.Bind().ParseEndpoint(connurl) //trying to bind first url in the list and wait device.DRoute.P2P.PeerAliveTimeout seconds
 						if err != nil {
-							device.log.Errorf("Can't bind " + url)
+							device.log.Errorf("Can't bind " + connurl)
-							thepeer.endpoint_trylist.Delete(url)
+							thepeer.Lock()
-							return true
+							thepeer.endpoint_trylist.Delete(connurl)
+							thepeer.Unlock()
+							continue
 						}
 						if device.LogLevel.LogControl {
 							fmt.Println("Control: Set endpoint to " + endpoint.DstToString() + " for NodeID:" + thepeer.ID.ToString())
 						}
 						thepeer.SetEndpointFromPacket(endpoint)
 						NextRun = true
-						thepeer.endpoint_trylist.Store(key, time.Now())
+						thepeer.Lock()
+						thepeer.endpoint_trylist.Set(key, time.Now())
+						thepeer.Unlock()
 						//Send Ping message to it
-						packet, err := device.GeneratePingPacket(device.ID)
+						packet, usage, err := device.GeneratePingPacket(device.ID)
-						device.SendPacket(thepeer, packet, MessageTransportOffsetContent)
+						device.SendPacket(thepeer, usage, packet, MessageTransportOffsetContent)
-
+						break
-						return false
 					}
-					return true
+				}
-				})
 			}
 		}
 	ClearChanLoop:
@@ -524,8 +562,8 @@ func (device *Device) RoutineSendPing() {
 		return
 	}
 	for {
-		packet, _ := device.GeneratePingPacket(device.ID)
+		packet, usage, _ := device.GeneratePingPacket(device.ID)
-		device.SpreadPacket(make(map[config.Vertex]bool), packet, MessageTransportOffsetContent)
+		device.SpreadPacket(make(map[config.Vertex]bool), usage, packet, MessageTransportOffsetContent)
 		time.Sleep(path.S2TD(device.DRoute.SendPingInterval))
 	}
 }
@@ -547,10 +585,9 @@ func (device *Device) RoutineRegister() {
 		header.SetDst(config.SuperNodeMessage)
 		header.SetTTL(0)
 		header.SetSrc(device.ID)
-		header.SetUsage(path.Register)
 		header.SetPacketLength(uint16(len(body)))
 		copy(buf[path.EgHeaderLen:], body)
-		device.Send2Super(buf, MessageTransportOffsetContent)
+		device.Send2Super(path.Register, buf, MessageTransportOffsetContent)
 		time.Sleep(path.S2TD(device.DRoute.SendPingInterval))
 	}
 }
@@ -612,26 +649,25 @@ func (device *Device) RoutineResetConn() {
 	}
 }
 
-func (device *Device) GeneratePingPacket(src_nodeID config.Vertex) ([]byte, error) {
+func (device *Device) GeneratePingPacket(src_nodeID config.Vertex) ([]byte, path.Usage, error) {
 	body, err := path.GetByte(&path.PingMsg{
 		Src_nodeID: src_nodeID,
 		Time:       device.graph.GetCurrentTime(),
 	})
 	if err != nil {
-		return nil, err
+		return nil, path.PingPacket, err
 	}
 	buf := make([]byte, path.EgHeaderLen+len(body))
 	header, _ := path.NewEgHeader(buf[0:path.EgHeaderLen])
 	if err != nil {
-		return nil, err
+		return nil, path.PingPacket, err
 	}
 	header.SetDst(config.ControlMessage)
 	header.SetTTL(0)
 	header.SetSrc(device.ID)
-	header.SetUsage(path.PingPacket)
 	header.SetPacketLength(uint16(len(body)))
 	copy(buf[path.EgHeaderLen:], body)
-	return buf, nil
+	return buf, path.PingPacket, nil
 }
 
 func (device *Device) process_RequestPeerMsg(content path.QueryPeerMsg) error { //Send all my peers to all my peers
@@ -663,10 +699,9 @@ func (device *Device) process_RequestPeerMsg(content path.QueryPeerMsg) error {
 			header.SetDst(config.ControlMessage)
 			header.SetTTL(device.DefaultTTL)
 			header.SetSrc(device.ID)
-			header.SetUsage(path.BoardcastPeer)
 			header.SetPacketLength(uint16(len(body)))
 			copy(buf[path.EgHeaderLen:], body)
-			device.SpreadPacket(make(map[config.Vertex]bool), buf, MessageTransportOffsetContent)
+			device.SpreadPacket(make(map[config.Vertex]bool), path.BoardcastPeer, buf, MessageTransportOffsetContent)
 		}
 		device.peers.RUnlock()
 	}
@@ -675,18 +710,18 @@ func (device *Device) process_RequestPeerMsg(content path.QueryPeerMsg) error {
 
 func (device *Device) process_BoardcastPeerMsg(peer *Peer, content path.BoardcastPeerMsg) error {
 	if device.DRoute.P2P.UseP2P {
-		var sk NoisePublicKey
+		var pk NoisePublicKey
 		if content.Request_ID == uint32(device.ID) {
 			peer.AskedForNeighbor = true
 		}
 		if bytes.Equal(content.PubKey[:], device.staticIdentity.publicKey[:]) {
 			return nil
 		}
-		copy(sk[:], content.PubKey[:])
+		copy(pk[:], content.PubKey[:])
-		thepeer := device.LookupPeer(sk)
+		thepeer := device.LookupPeer(pk)
 		if thepeer == nil { //not exist in local
 			if device.LogLevel.LogControl {
-				fmt.Println("Control: Add new peer to local ID:" + content.NodeID.ToString() + " PubKey:" + base64.StdEncoding.EncodeToString(content.PubKey[:]))
+				fmt.Println("Control: Add new peer to local ID:" + content.NodeID.ToString() + " PubKey:" + pk.ToString())
 			}
 			if device.graph.Weight(device.ID, content.NodeID) == path.Infinity { // add node to graph
 				device.graph.UpdateLentancy(device.ID, content.NodeID, path.S2TD(path.Infinity), true, false)
@@ -694,15 +729,17 @@ func (device *Device) process_BoardcastPeerMsg(peer *Peer, content path.Boardcas
 			if device.graph.Weight(content.NodeID, device.ID) == path.Infinity { // add node to graph
 				device.graph.UpdateLentancy(content.NodeID, device.ID, path.S2TD(path.Infinity), true, false)
 			}
-			device.NewPeer(sk, content.NodeID)
+			device.NewPeer(pk, content.NodeID)
-			thepeer = device.LookupPeer(sk)
+			thepeer = device.LookupPeer(pk)
 			var pk NoisePresharedKey
 			copy(pk[:], content.PSKey[:])
 			thepeer.handshake.presharedKey = pk
 		}
 		if thepeer.LastPingReceived.Add(path.S2TD(device.DRoute.P2P.PeerAliveTimeout)).Before(time.Now()) {
 			//Peer died, try to switch to this new endpoint
-			thepeer.endpoint_trylist.Store(content.ConnURL, time.Time{}) //another gorouting will process it
+			thepeer.Lock()
+			thepeer.endpoint_trylist.Set(content.ConnURL, time.Time{}) //another gorouting will process it
+			thepeer.Unlock()
 			device.event_tryendpoint <- struct{}{}
 		}
 

device/send.go

@@ -47,6 +47,7 @@ import (
  */
 
 type QueueOutboundElement struct {
+	Type path.Usage
 	sync.Mutex
 	buffer  *[MaxMessageSize]byte // slice holding the packet data
 	packet  []byte                // slice of "buffer" (always!)
@@ -263,7 +264,7 @@ func (device *Device) RoutineReadFromTUN() {
 		EgBody.SetDst(dst_nodeID)
 		EgBody.SetPacketLength(uint16(len(elem.packet) - path.EgHeaderLen))
 		EgBody.SetTTL(device.DefaultTTL)
-		EgBody.SetUsage(path.NornalPacket)
+		elem.Type = path.NornalPacket
 
 		if dst_nodeID != config.Boardcast {
 			var peer *Peer
@@ -283,7 +284,7 @@ func (device *Device) RoutineReadFromTUN() {
 				}
 			}
 		} else {
-			device.BoardcastPacket(make(map[config.Vertex]bool, 0), elem.packet, offset)
+			device.BoardcastPacket(make(map[config.Vertex]bool, 0),elem.Type, elem.packet, offset)
 		}
 
 	}
@@ -388,11 +389,10 @@ func (device *Device) RoutineEncryption(id int) {
 		// populate header fields
 		header := elem.buffer[:MessageTransportHeaderSize]
 
-		fieldType := header[0:4]
+		fieldReceiver := header[1:5]
-		fieldReceiver := header[4:8]
+		fieldNonce := header[5:13]
-		fieldNonce := header[8:16]
 
-		binary.LittleEndian.PutUint32(fieldType, MessageTransportType)
+		header[0] = uint8(elem.Type)
 		binary.LittleEndian.PutUint32(fieldReceiver, elem.keypair.remoteIndex)
 		binary.LittleEndian.PutUint64(fieldNonce, elem.nonce)
 

example_config/p2p_mode/n1.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap1
   vppifaceid: 1
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4001
   sendaddr: 127.0.0.1:5001
   l2headermode: kbdbg

example_config/p2p_mode/n2.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap2
   vppifaceid: 2
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4002
   sendaddr: 127.0.0.1:5002
   l2headermode: kbdbg

example_config/p2p_mode/n3.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap3
   vppifaceid: 3
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4003
   sendaddr: 127.0.0.1:5003
   l2headermode: kbdbg

example_config/p2p_mode/n4.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap4
   vppifaceid: 4
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4004
   sendaddr: 127.0.0.1:5004
   l2headermode: kbdbg

example_config/p2p_mode/n5.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap5
   vppifaceid: 5
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4005
   sendaddr: 127.0.0.1:5005
   l2headermode: kbdbg

example_config/p2p_mode/n6.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap6
   vppifaceid: 6
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4006
   sendaddr: 127.0.0.1:5006
   l2headermode: kbdbg

example_config/static_mode/n1.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap1
   vppifaceid: 1
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4001
   sendaddr: 127.0.0.1:5001
   l2headermode: kbdbg

example_config/static_mode/n2.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap2
   vppifaceid: 2
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4002
   sendaddr: 127.0.0.1:5002
   l2headermode: kbdbg

example_config/static_mode/n3.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap3
   vppifaceid: 3
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4003
   sendaddr: 127.0.0.1:5003
   l2headermode: kbdbg

example_config/static_mode/n4.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap4
   vppifaceid: 4
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4004
   sendaddr: 127.0.0.1:5004
   l2headermode: kbdbg

example_config/static_mode/n5.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap5
   vppifaceid: 5
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4005
   sendaddr: 127.0.0.1:5005
   l2headermode: kbdbg

example_config/static_mode/n6.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap6
   vppifaceid: 6
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4006
   sendaddr: 127.0.0.1:5006
   l2headermode: kbdbg

example_config/super_mode/n1.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap1
   vppifaceid: 1
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4001
   sendaddr: 127.0.0.1:5001
   l2headermode: kbdbg
@@ -20,7 +20,7 @@ loglevel:
   lognormal: true
   logntp: true
 dynamicroute:
-  sendpinginterval: 20
+  sendpinginterval: 16
   dupchecktimeout: 40
   conntimeout: 30
   savenewpeers: true
@@ -28,10 +28,10 @@ dynamicroute:
     usesupernode: true
     connurlv4: 127.0.0.1:3000
     pubkeyv4: LJ8KKacUcIoACTGB/9Ed9w0osrJ3WWeelzpL2u4oUic=
-    connurlv6: ''
+    connurlv6: '[::1]:3000'
     pubkeyv6: HCfL6YJtpJEGHTlJ2LgVXIWKB/K95P57LHTJ42ZG8VI=
     apiurl: http://127.0.0.1:3000/api
-    supernodeinfotimeout: 40
+    supernodeinfotimeout: 50
   p2p:
     usep2p: false
     sendpeerinterval: 20

example_config/super_mode/n2.yaml

@@ -3,8 +3,8 @@ interface:
   name: tap2
   vppifaceid: 2
   vppbridgeid: 4242
-  macaddrprefix: AA:BB:CC:DD:EE
+  macaddrprefix: AA:BB:CC:DD
-  mtu: 1404
+  mtu: 1416
   recvaddr: 127.0.0.1:4002
   sendaddr: 127.0.0.1:5002
   l2headermode: kbdbg
@@ -20,7 +20,7 @@ loglevel:
   lognormal: true
   logntp: true
 dynamicroute:
-  sendpinginterval: 20
+  sendpinginterval: 16
   dupchecktimeout: 40
   conntimeout: 30
   savenewpeers: true
@@ -28,10 +28,10 @@ dynamicroute:
     usesupernode: true
     connurlv4: 127.0.0.1:3000
     pubkeyv4: LJ8KKacUcIoACTGB/9Ed9w0osrJ3WWeelzpL2u4oUic=
-    connurlv6: ''
+    connurlv6: '[::1]:3000'
     pubkeyv6: HCfL6YJtpJEGHTlJ2LgVXIWKB/K95P57LHTJ42ZG8VI=
     apiurl: http://127.0.0.1:3000/api
-    supernodeinfotimeout: 40
+    supernodeinfotimeout: 50
   p2p:
     usep2p: false
     sendpeerinterval: 20

example_config/super_mode/s1.yaml

@@ -2,7 +2,10 @@ nodename: NodeSuper
 privkeyv4: mL5IW0GuqbjgDeOJuPHBU2iJzBPNKhaNEXbIGwwYWWk=
 privkeyv6: +EdOKIoBp/EvIusHDsvXhV1RJYbyN3Qr8nxlz35wl3I=
 listenport: 3000
-statepassword: passwd
+passwords:
+  showstate: passwd
+  addpeer: passwd_addpeer
+  delpeer: passwd_delpeer
 loglevel:
   loglevel: normal
   logtransit: true
@@ -12,8 +15,9 @@ repushconfiginterval: 30
 graphrecalculatesetting:
   jittertolerance: 5
   jittertolerancemultiplier: 1.01
-  nodereporttimeout: 40
+  nodereporttimeout: 50
   recalculatecooldown: 5
+edgetemplate: "example_config/super_mode/s1.yaml"
 peers:
 - nodeid: 1
   name: "Node_01"
@@ -22,4 +26,4 @@ peers:
 - nodeid: 2
   name: "Node_02"
   pubkey: dHeWQtlTPQGy87WdbUARS4CtwVaR2y7IQ1qcX4GKSXk=
-  pskey: ""
+  pskey: ""

main.go

@@ -55,7 +55,7 @@ var (
 func main() {
 	flag.Parse()
 	if *version == true {
-		fmt.Printf("etherguard-go v%s\n%s\n\nA full mesh VPN %s-%s.\nInformation available at https://github.com/KusakabeSi/EtherGuardVPN.\nCopyright (C) Kusakabe Si <si@kskb.eu.org>.\n", Version, tap.VPP_SUPPORT, runtime.GOOS, runtime.GOARCH)
+		fmt.Printf("etherguard-go %s\n%s\n\nA full mesh VPN %s-%s.\nInformation available at https://github.com/KusakabeSi/EtherGuardVPN.\nCopyright (C) Kusakabe Si <si@kskb.eu.org>.\n", Version, tap.VPP_SUPPORT, runtime.GOOS, runtime.GOARCH)
 		return
 	}
 	if *help == true {

main_edge.go

@@ -8,7 +8,6 @@
 package main
 
 import (
-	"encoding/base64"
 	"errors"
 	"fmt"
 	"net"
@@ -210,24 +209,29 @@ func Edge(configPath string, useUAPI bool, printExample bool) (err error) {
 	graph := path.NewGraph(3, false, econfig.DynamicRoute.P2P.GraphRecalculateSetting, econfig.DynamicRoute.NTPconfig, econfig.LogLevel.LogNTP)
 	graph.SetNHTable(econfig.NextHopTable, [32]byte{})
 
-	the_device := device.NewDevice(thetap, econfig.NodeID, conn.NewDefaultBind(), logger, graph, false, configPath, &econfig, nil, nil,Version)
+	the_device := device.NewDevice(thetap, econfig.NodeID, conn.NewDefaultBind(), logger, graph, false, configPath, &econfig, nil, nil, Version)
 	defer the_device.Close()
-	var sk [32]byte
+	pk, err := device.Str2PriKey(econfig.PrivKey)
-	sk_slice, _ := base64.StdEncoding.DecodeString(econfig.PrivKey)
+	if err != nil {
-	copy(sk[:], sk_slice)
+		fmt.Println("Error decode base64 ", err)
-	the_device.SetPrivateKey(sk)
+		return err
+	}
+	the_device.SetPrivateKey(pk)
 	the_device.IpcSet("fwmark=0\n")
 	the_device.IpcSet("listen_port=" + strconv.Itoa(econfig.ListenPort) + "\n")
 	the_device.IpcSet("replace_peers=true\n")
 	for _, peerconf := range econfig.Peers {
-		sk_slice, _ = base64.StdEncoding.DecodeString(peerconf.PubKey)
+		pk, err := device.Str2PubKey(peerconf.PubKey)
-		copy(sk[:], sk_slice)
+		if err != nil {
+			fmt.Println("Error decode base64 ", err)
+			return err
+		}
 		if peerconf.NodeID >= config.SuperNodeMessage {
 			return errors.New(fmt.Sprintf("Invalid Node_id at peer %s\n", peerconf.PubKey))
 		}
-		the_device.NewPeer(sk, peerconf.NodeID)
+		the_device.NewPeer(pk, peerconf.NodeID)
 		if peerconf.EndPoint != "" {
-			peer := the_device.LookupPeer(sk)
+			peer := the_device.LookupPeer(pk)
 			endpoint, err := the_device.Bind().ParseEndpoint(peerconf.EndPoint)
 			if err != nil {
 				logger.Errorf("Failed to set endpoint %v: %w", peerconf.EndPoint, err)
@@ -241,13 +245,16 @@ func Edge(configPath string, useUAPI bool, printExample bool) (err error) {
 
 	if econfig.DynamicRoute.SuperNode.UseSuperNode {
 		if econfig.DynamicRoute.SuperNode.ConnURLV4 != "" {
-			sk_slice, _ = base64.StdEncoding.DecodeString(econfig.DynamicRoute.SuperNode.PubKeyV4)
+			pk, err := device.Str2PubKey(econfig.DynamicRoute.SuperNode.PubKeyV4)
-			copy(sk[:], sk_slice)
+			if err != nil {
+				fmt.Println("Error decode base64 ", err)
+				return err
+			}
 			endpoint, err := the_device.Bind().ParseEndpoint(econfig.DynamicRoute.SuperNode.ConnURLV4)
 			if err != nil {
 				return err
 			}
-			peer, err := the_device.NewPeer(sk, config.SuperNodeMessage)
+			peer, err := the_device.NewPeer(pk, config.SuperNodeMessage)
 			if err != nil {
 				return err
 			}
@@ -256,13 +263,15 @@ func Edge(configPath string, useUAPI bool, printExample bool) (err error) {
 			peer.SetEndpointFromPacket(endpoint)
 		}
 		if econfig.DynamicRoute.SuperNode.ConnURLV6 != "" {
-			sk_slice, _ = base64.StdEncoding.DecodeString(econfig.DynamicRoute.SuperNode.PubKeyV6)
+			pk, err := device.Str2PubKey(econfig.DynamicRoute.SuperNode.PubKeyV6)
-			copy(sk[:], sk_slice)
+			if err != nil {
+				fmt.Println("Error decode base64 ", err)
+			}
 			endpoint, err := the_device.Bind().ParseEndpoint(econfig.DynamicRoute.SuperNode.ConnURLV6)
 			if err != nil {
 				return err
 			}
-			peer, err := the_device.NewPeer(sk, config.SuperNodeMessage)
+			peer, err := the_device.NewPeer(pk, config.SuperNodeMessage)
 			if err != nil {
 				return err
 			}

main_super.go

@@ -10,7 +10,6 @@ package main
 import (
 	"bytes"
 	"crypto/md5"
-	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
@@ -105,52 +104,54 @@ func Super(configPath string, useUAPI bool, printExample bool) (err error) {
 	http_PeerID2Map = make(map[config.Vertex]string)
 	http_PeerInfos = make(map[string]config.HTTP_Peerinfo)
 	http_HashSalt = []byte(config.RandomStr(32, "Salt generate failed"))
-	http_StatePWD = sconfig.StatePassword
+	http_StatePWD = sconfig.Passwords.ShowState
 
 	super_chains := path.SUPER_Events{
 		Event_server_pong:            make(chan path.PongMsg, 1<<5),
 		Event_server_register:        make(chan path.RegisterMsg, 1<<5),
 		Event_server_NhTable_changed: make(chan struct{}, 1<<4),
 	}
+	http_graph = path.NewGraph(3, true, sconfig.GraphRecalculateSetting, config.NTPinfo{}, sconfig.LogLevel.LogNTP)
 
 	thetap4, _ := tap.CreateDummyTAP()
-	thetap6, _ := tap.CreateDummyTAP()
-	http_graph = path.NewGraph(3, true, sconfig.GraphRecalculateSetting, config.NTPinfo{}, sconfig.LogLevel.LogNTP)
 	http_device4 = device.NewDevice(thetap4, config.SuperNodeMessage, conn.NewCustomBind(true, false), logger4, http_graph, true, configPath, nil, &sconfig, &super_chains, Version)
-	http_device6 = device.NewDevice(thetap6, config.SuperNodeMessage, conn.NewCustomBind(false, true), logger6, http_graph, true, configPath, nil, &sconfig, &super_chains, Version)
 	defer http_device4.Close()
+	thetap6, _ := tap.CreateDummyTAP()
+	http_device6 = device.NewDevice(thetap6, config.SuperNodeMessage, conn.NewCustomBind(false, true), logger6, http_graph, true, configPath, nil, &sconfig, &super_chains, Version)
 	defer http_device6.Close()
-	var sk [32]byte
+	if sconfig.PrivKeyV4 != "" {
-	sk_slice, err := base64.StdEncoding.DecodeString(sconfig.PrivKeyV4)
+		pk4, err := device.Str2PriKey(sconfig.PrivKeyV4)
-	if err != nil {
+		if err != nil {
-		fmt.Printf("Can't decode base64:%v\n", sconfig.PrivKeyV4)
+			fmt.Println("Error decode base64 ", err)
-		return err
+			return err
+		}
+		http_device4.SetPrivateKey(pk4)
+		http_device4.IpcSet("fwmark=0\n")
+		http_device4.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
+		http_device4.IpcSet("replace_peers=true\n")
 	}
-	copy(sk[:], sk_slice)
+
-	http_device4.SetPrivateKey(sk)
+	if sconfig.PrivKeyV6 != "" {
-	sk_slice, err = base64.StdEncoding.DecodeString(sconfig.PrivKeyV6)
+
-	if err != nil {
+		pk6, err := device.Str2PriKey(sconfig.PrivKeyV6)
-		fmt.Printf("Can't decode base64:%v\n", sconfig.PrivKeyV6)
+		if err != nil {
-		return err
+			fmt.Println("Error decode base64 ", err)
+			return err
+		}
+		http_device6.SetPrivateKey(pk6)
+		http_device6.IpcSet("fwmark=0\n")
+		http_device6.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
+		http_device6.IpcSet("replace_peers=true\n")
 	}
-	copy(sk[:], sk_slice)
-	http_device6.SetPrivateKey(sk)
-	http_device4.IpcSet("fwmark=0\n")
-	http_device6.IpcSet("fwmark=0\n")
-	http_device4.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
-	http_device6.IpcSet("listen_port=" + strconv.Itoa(sconfig.ListenPort) + "\n")
-	http_device4.IpcSet("replace_peers=true\n")
-	http_device6.IpcSet("replace_peers=true\n")
 
 	for _, peerconf := range sconfig.Peers {
 		http_peerinfos.Store(peerconf.NodeID, peerconf.Name)
-		var pk device.NoisePublicKey
+		pk, err := device.Str2PubKey(peerconf.PubKey)
-
-		pk_slice, err := base64.StdEncoding.DecodeString(peerconf.PubKey)
 		if err != nil {
 			fmt.Println("Error decode base64 ", err)
+			return err
 		}
-		copy(pk[:], pk_slice)
+
 		if peerconf.NodeID >= config.SuperNodeMessage {
 			return errors.New(fmt.Sprintf("Invalid Node_id at peer %s\n", peerconf.PubKey))
 		}
@@ -161,31 +162,43 @@ func Super(configPath string, useUAPI bool, printExample bool) (err error) {
 			PSKey:   peerconf.PSKey,
 			Connurl: make(map[string]bool),
 		}
-		peer4, err := http_device4.NewPeer(pk, peerconf.NodeID)
+		if sconfig.PrivKeyV4 != "" {
-		if err != nil {
+			peer4, err := http_device4.NewPeer(pk, peerconf.NodeID)
-			fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
-			return err
-		}
-		peer4.StaticConn = true
-		peer6, err := http_device6.NewPeer(pk, peerconf.NodeID)
-		if err != nil {
-			fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
-			return err
-		}
-		peer6.StaticConn = true
-		if peerconf.PSKey != "" {
-			var psk device.NoisePresharedKey
-			psk_slice, err := base64.StdEncoding.DecodeString(peerconf.PSKey)
 			if err != nil {
-				fmt.Println("Error decode base64 ", err)
+				fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
+				return err
+			}
+			peer4.StaticConn = true
+			if peerconf.PSKey != "" {
+				psk, err := device.Str2PSKey(peerconf.PSKey)
+				if err != nil {
+					fmt.Println("Error decode base64 ", err)
+					return err
+				}
+				peer4.SetPSK(psk)
 			}
-			copy(psk[:], psk_slice)
-			peer4.SetPSK(psk)
-			peer6.SetPSK(psk)
 		}
+		if sconfig.PrivKeyV6 != "" {
+			peer6, err := http_device6.NewPeer(pk, peerconf.NodeID)
+			if err != nil {
+				fmt.Printf("Error create peer id %v\n", peerconf.NodeID)
+				return err
+			}
+			peer6.StaticConn = true
+			if peerconf.PSKey != "" {
+				psk, err := device.Str2PSKey(peerconf.PSKey)
+				if err != nil {
+					fmt.Println("Error decode base64 ", err)
+					return err
+				}
+				peer6.SetPSK(psk)
+			}
+		}
+
 		http_PeerState[peerconf.PubKey] = &PeerState{}
 	}
-	logger4.Verbosef("Device started")
+	logger4.Verbosef("Device4 started")
+	logger6.Verbosef("Device6 started")
 
 	errs := make(chan error, 1<<3)
 	term := make(chan os.Signal, 1)
@@ -290,14 +303,13 @@ func PushNhTable() {
 	header.SetPacketLength(uint16(len(body)))
 	header.SetSrc(config.SuperNodeMessage)
 	header.SetTTL(0)
-	header.SetUsage(path.UpdateNhTable)
 	copy(buf[path.EgHeaderLen:], body)
 	for pkstr, _ := range http_PeerState {
 		if peer := http_device4.LookupPeerByStr(pkstr); peer != nil && peer.GetEndpointDstStr() != "" {
-			http_device4.SendPacket(peer, buf, device.MessageTransportOffsetContent)
+			http_device4.SendPacket(peer, path.UpdateNhTable, buf, device.MessageTransportOffsetContent)
 		}
 		if peer := http_device6.LookupPeerByStr(pkstr); peer != nil && peer.GetEndpointDstStr() != "" {
-			http_device6.SendPacket(peer, buf, device.MessageTransportOffsetContent)
+			http_device6.SendPacket(peer, path.UpdateNhTable, buf, device.MessageTransportOffsetContent)
 		}
 
 	}
@@ -317,15 +329,14 @@ func PushUpdate() {
 	header.SetPacketLength(uint16(len(body)))
 	header.SetSrc(config.SuperNodeMessage)
 	header.SetTTL(0)
-	header.SetUsage(path.UpdatePeer)
 	copy(buf[path.EgHeaderLen:], body)
 	for pkstr, peerstate := range http_PeerState {
 		if peerstate.PeerInfoState != http_PeerInfo_hash {
 			if peer := http_device4.LookupPeerByStr(pkstr); peer != nil {
-				http_device4.SendPacket(peer, buf, device.MessageTransportOffsetContent)
+				http_device4.SendPacket(peer, path.UpdatePeer, buf, device.MessageTransportOffsetContent)
 			}
 			if peer := http_device6.LookupPeerByStr(pkstr); peer != nil {
-				http_device6.SendPacket(peer, buf, device.MessageTransportOffsetContent)
+				http_device6.SendPacket(peer, path.UpdatePeer, buf, device.MessageTransportOffsetContent)
 			}
 		}
 	}

orderdmap/orderdmap.go

@@ -34,12 +34,12 @@ type OrderedMap struct {
 	escapeHTML bool
 }
 
-func New() *OrderedMap {
+func New() OrderedMap {
 	o := OrderedMap{}
 	o.keys = []string{}
 	o.values = map[string]interface{}{}
 	o.escapeHTML = true
-	return &o
+	return o
 }
 
 func (o *OrderedMap) SetEscapeHTML(on bool) {
@@ -77,7 +77,11 @@ func (o *OrderedMap) Delete(key string) {
 }
 
 func (o *OrderedMap) Keys() []string {
-	return o.keys
+	ret := make([]string, len(o.keys))
+	for i, v := range o.keys {
+		ret[i] = v
+	}
+	return ret
 }
 
 // SortKeys Sort the map keys using your sort func

path/header.go

@@ -7,7 +7,7 @@ import (
 	"github.com/KusakabeSi/EtherGuardVPN/config"
 )
 
-const EgHeaderLen = 8
+const EgHeaderLen = 7
 
 type EgHeader struct {
 	buf []byte
@@ -16,8 +16,13 @@ type EgHeader struct {
 type Usage uint8
 
 const (
-	NornalPacket Usage = iota
+	MessageInitiationType Usage = iota
-	Register           //Register to server
+	MessageResponseType
+	MessageCookieReplyType
+	MessageTransportType
+
+	NornalPacket
+	Register //Register to server
 
 	UpdatePeer //Comes from server
 	UpdateNhTable
@@ -56,20 +61,12 @@ func (e EgHeader) GetTTL() uint8 {
 	return e.buf[4]
 }
 func (e EgHeader) SetTTL(ttl uint8) {
-
 	e.buf[4] = ttl
 }
 
-func (e EgHeader) GetUsage() Usage {
-	return Usage(e.buf[5])
-}
-func (e EgHeader) SetUsage(usage Usage) {
-	e.buf[5] = uint8(usage)
-}
-
 func (e EgHeader) GetPacketLength() uint16 {
-	return binary.BigEndian.Uint16(e.buf[6:8])
+	return binary.BigEndian.Uint16(e.buf[5:7])
 }
 func (e EgHeader) SetPacketLength(length uint16) {
-	binary.BigEndian.PutUint16(e.buf[6:8], length)
+	binary.BigEndian.PutUint16(e.buf[5:7], length)
 }

path/ntp.go

@@ -17,7 +17,7 @@ func (g *IG) InitNTP() {
 			g.ntp_info.UseNTP = false
 			return
 		}
-		g.ntp_servers = *orderedmap.New()
+		g.ntp_servers = orderedmap.New()
 		for _, url := range g.ntp_info.Servers {
 			g.ntp_servers.Set(url, ntp.Response{
 				RTT: forever,

tap/tap_vpp_fake.go

@@ -9,7 +9,7 @@ import (
 )
 
 const (
-	VPP_SUPPORT = "No VPP support"
+	VPP_SUPPORT = "VPP support disabled"
 )
 
 type VppTap struct {
@@ -18,8 +18,8 @@ type VppTap struct {
 }
 
 // New creates and returns a new TUN interface for the application.
-func CreateVppTAP(iconfig config.InterfaceConf,NodeID config.Vertex, loglevel string) (tapdev Device, err error) {
+func CreateVppTAP(iconfig config.InterfaceConf, NodeID config.Vertex, loglevel string) (tapdev Device, err error) {
-	return nil, errors.New("VPP module not compiled.")
+	return nil, errors.New("VPP support disabled.")
 }
 
 func (tap *VppTap) Read([]byte, int) (int, error) {