issue #23 peer client preshared key, update dependencies

core/client.go

@@ -42,6 +42,12 @@ func CreateClient(client *model.Client) (*model.Client, error) {
 	client.PrivateKey = key.String()
 	client.PublicKey = key.PublicKey().String()
 
+	presharedKey, err := wgtypes.GenerateKey()
+	if err != nil {
+		return nil, err
+	}
+	client.PresharedKey = presharedKey.String()
+
 	reserverIps, err := GetAllReservedIps()
 	if err != nil {
 		return nil, err

core/migrate.go

@@ -15,7 +15,7 @@ import (
 )
 
 // Migrate all changes, current struct fields change
-func Migrate() error {
+func MigrateInitialStructChange() error {
 	clients, err := readClients()
 	if err != nil {
 		return err
@@ -98,7 +98,7 @@ func Migrate() error {
 	server.ListenPort = int(s["listenPort"].(float64))
 	server.PrivateKey = s["privateKey"].(string)
 	server.PublicKey = s["publicKey"].(string)
-	server.PresharedKey = s["presharedKey"].(string)
+	//server.PresharedKey = s["presharedKey"].(string)
 	server.Endpoint = s["endpoint"].(string)
 	server.PersistentKeepalive = int(s["persistentKeepalive"].(float64))
 	server.Dns = make([]string, 0)
@@ -144,6 +144,122 @@ func Migrate() error {
 	return nil
 }
 
+// Migrate presharedKey issue #23
+func MigratePresharedKey() error {
+	clients, err := readClients()
+	if err != nil {
+		return err
+	}
+
+	s, err := deserialize("server.json")
+	if err != nil {
+		return err
+	}
+
+	for _, client := range clients {
+		if _, ok := client["presharedKey"]; ok {
+			log.Infof("client %s has been already migrated for preshared key", client["id"])
+			continue
+		}
+
+		c := &model.Client{}
+		c.Id = client["id"].(string)
+		c.Name = client["name"].(string)
+		c.Email = client["email"].(string)
+		c.Enable = client["enable"].(bool)
+		c.IgnorePersistentKeepalive = client["ignorePersistentKeepalive"].(bool)
+		c.PresharedKey = s["presharedKey"].(string)
+		c.AllowedIPs = make([]string, 0)
+		for _, address := range client["allowedIPs"].([]interface{}) {
+			c.AllowedIPs = append(c.AllowedIPs, address.(string))
+		}
+		c.Address = make([]string, 0)
+		for _, address := range client["address"].([]interface{}) {
+			c.Address = append(c.Address, address.(string))
+		}
+		c.PrivateKey = client["privateKey"].(string)
+		c.PublicKey = client["publicKey"].(string)
+		created, err := time.Parse(time.RFC3339, client["created"].(string))
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to parse time")
+			continue
+		}
+		c.Created = created
+		updated, err := time.Parse(time.RFC3339, client["updated"].(string))
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to parse time")
+			continue
+		}
+		c.Updated = updated
+
+		err = storage.Serialize(c.Id, c)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to Serialize client")
+		}
+	}
+
+	if _, ok := s["presharedKey"]; ok {
+		server := &model.Server{}
+
+		server.Address = make([]string, 0)
+		server.Address = make([]string, 0)
+		for _, address := range s["address"].([]interface{}) {
+			server.Address = append(server.Address, address.(string))
+		}
+		server.ListenPort = int(s["listenPort"].(float64))
+		server.PrivateKey = s["privateKey"].(string)
+		server.PublicKey = s["publicKey"].(string)
+		server.Endpoint = s["endpoint"].(string)
+		server.PersistentKeepalive = int(s["persistentKeepalive"].(float64))
+		server.Dns = make([]string, 0)
+		for _, address := range s["dns"].([]interface{}) {
+			server.Dns = append(server.Dns, address.(string))
+		}
+		if val, ok := s["preUp"]; ok {
+			server.PreUp = val.(string)
+		}
+		if val, ok := s["postUp"]; ok {
+			server.PostUp = val.(string)
+		}
+		if val, ok := s["preDown"]; ok {
+			server.PreDown = val.(string)
+		}
+		if val, ok := s["postDown"]; ok {
+			server.PostDown = val.(string)
+		}
+		created, err := time.Parse(time.RFC3339, s["created"].(string))
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to parse time")
+		}
+		server.Created = created
+		updated, err := time.Parse(time.RFC3339, s["updated"].(string))
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to parse time")
+		}
+		server.Updated = updated
+
+		err = storage.Serialize("server.json", server)
+		if err != nil {
+			log.WithFields(log.Fields{
+				"err": err,
+			}).Errorf("failed to Serialize server")
+		}
+
+	}
+
+	return nil
+}
+
 func readClients() ([]map[string]interface{}, error) {
 	clients := make([]map[string]interface{}, 0)
 

core/server.go

@@ -25,12 +25,6 @@ func ReadServer() (*model.Server, error) {
 		server.PrivateKey = key.String()
 		server.PublicKey = key.PublicKey().String()
 
-		presharedKey, err := wgtypes.GenerateKey()
-		if err != nil {
-			return nil, err
-		}
-		server.PresharedKey = presharedKey.String()
-
 		server.Endpoint = "wireguard.example.com:123"
 		server.ListenPort = 51820
 
@@ -91,7 +85,7 @@ func UpdateServer(server *model.Server) (*model.Server, error) {
 
 	server.PrivateKey = current.(*model.Server).PrivateKey
 	server.PublicKey = current.(*model.Server).PublicKey
-	server.PresharedKey = current.(*model.Server).PresharedKey
+	//server.PresharedKey = current.(*model.Server).PresharedKey
 	server.Updated = time.Now().UTC()
 
 	err = storage.Serialize("server.json", server)