WIP implement pass functs

cmd/ppass/ppass.go

@@ -47,10 +47,10 @@ func main() {
 	fmt.Printf("AgeKey: %s\n", key.String())
 	fmt.Printf("AgePublicKey: %s\n", key.Recipient().String())
 
-	cipher, err := age.Encrypt([]byte("Test Message"), []string{key.Recipient().String()})
+	//cipher, err := age.Encrypt([]byte("Test Message"), []string{key.Recipient().String()})
-	fmt.Printf("Encrypted: %s\n", cipher)
+	//fmt.Printf("Encrypted: %s\n", cipher)
-	decrypted, err := age.Decrypt(cipher, key)
+	//decrypted, err := age.Decrypt(cipher, key)
-	fmt.Printf("Decrypted: %s\n", decrypted)
+	//fmt.Printf("Decrypted: %s\n", decrypted)
 
 	h, dht, err := storage.SetupLibp2pHost(ctx, *dbPath)
 
@@ -84,6 +84,12 @@ func main() {
 		logger.Fatal(err)
 	}
 
+	Cfg, err := storage.NewConfig(*dbPath + "/config.json")
+
+	if err != nil {
+		logger.Fatal(err)
+	}
+
 	storageHandler := storage.StorageHandler{
 		Ctx: ctx ,
 		Store: store,
@@ -91,20 +97,13 @@ func main() {
 		Ipfs: ipfs,
 		PubSub: ps,
 		Key: key,
+		Config: Cfg,
 	}
 
-	Cfg := storage.NewConfig()
+	storageHandler.InitNamespaces()
 
-	Namespaces := make(map[string]*storage.Namespace)
+	for _, val := range storageHandler.Namespaces {
-	for _, nsCfg := range Cfg {
+		defer val.Close()
-		ns1, err := storage.CreateNamespace(nsCfg.Id, storageHandler)
-
-		if err != nil {
-			logger.Fatal(err)
-		}
-
-		Namespaces[nsCfg.Name] = ns1
-		defer ns1.Close()
 	}
 
 	fmt.Printf(`
@@ -186,7 +185,7 @@ Commands:
 		case "list":
 			if len(fields) < 2 {
 				fmt.Printf("Available Namespaces:\n")
-				for k := range Namespaces {
+				for k := range storageHandler.Namespaces {
 		      fmt.Printf("%s\n", k)
 				}
 				continue
@@ -196,7 +195,7 @@ Commands:
 
 			fmt.Printf("Listing content of %s", namespace)
 
-			val, ok := Namespaces[namespace]
+			val, ok := storageHandler.Namespaces[namespace]
 
 			if !ok {
 				fmt.Println("Namespace does not exist")
@@ -213,7 +212,7 @@ Commands:
 
 			namespace := fields[1]
 
-			val, ok := Namespaces[namespace]
+			val, ok := storageHandler.Namespaces[namespace]
 
 			if !ok {
 				fmt.Println("Namespace does not exist")
@@ -237,7 +236,7 @@ Commands:
 
 			namespace := fields[1]
 
-			val, ok := Namespaces[namespace]
+			val, ok := storageHandler.Namespaces[namespace]
 
 			if !ok {
 				fmt.Println("Namespace does not exist")
@@ -254,7 +253,7 @@ Commands:
 				continue
 			}
 
-			encryptedPassword, err := age.Encrypt(data, []string{key.Recipient().String()})
+			encryptedPassword, err := age.Encrypt(data, val.GetRecipients())
 			if err != nil {
 				printErr(err)
 				continue
@@ -274,7 +273,7 @@ Commands:
 
 			namespace := fields[1]
 
-			val, ok := Namespaces[namespace]
+			val, ok := storageHandler.Namespaces[namespace]
 
 			if !ok {
 				fmt.Println("Namespace does not exist")

storage/storage.go

@@ -4,10 +4,10 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"encoding/json"
 	"path/filepath"
 	"time"
 	"sync"
-	"io/ioutil"
 
 	"github.com/ipfs/go-datastore/query"
 	"github.com/libp2p/go-libp2p"
@@ -33,11 +33,12 @@ import (
 	logging "github.com/ipfs/go-log/v2"
 
   agelib "filippo.io/age"
+	password "github.com/k4lipso/pentapass/crypto"
 	"github.com/k4lipso/pentapass/crypto/age"
 )
 
 var (
-	topicNameFlag = "akdjlask-23klaj2idalj2-ajl2kjd3i-2ldakjd2"
+	topicNameFlag = "afbjlask-23klaj2idalj2-ajl2kjd3i-2ldakjd2"
 	logger    = logging.Logger("globaldb")
 	Listen = libp2p.ListenAddrStrings("/ip4/0.0.0.0/tcp/0")
 )
@@ -56,14 +57,14 @@ func SetupLibp2pHost(ctx context.Context, dbPath string) (host host.Host, dht *d
 		if err != nil {
 			logger.Fatal(err)
 		}
-		err = ioutil.WriteFile(keyPath, data, 0400)
+		err = os.WriteFile(keyPath, data, 0400)
 		if err != nil {
 			logger.Fatal(err)
 		}
 	} else if err != nil {
 		logger.Fatal(err)
 	} else {
-		key, err := ioutil.ReadFile(keyPath)
+		key, err := os.ReadFile(keyPath)
 		if err != nil {
 			logger.Fatal(err)
 		}
@@ -101,47 +102,35 @@ func SetupLibp2pHost(ctx context.Context, dbPath string) (host host.Host, dht *d
 }
 
 type Peer struct {
-	Id string
+	Id string `json:"Id"`
-	Key string
+	Key string `json:"Key"`
 }
 
 type NamespaceConfig struct {
-	Name string
+	Name string `json:"Name"`
-	Id string
+	Id string `json:"Id"`
-	Peers []Peer
+	Peers []Peer `json:"Peers"`
 }
 
 type Config []NamespaceConfig
 
-func NewConfig() []NamespaceConfig {
+func NewConfig(filename string) ([]NamespaceConfig, error) {
 	//fmt.Println("NewConfig Path not implemented yet")
-	return []NamespaceConfig{
+	content, err := os.ReadFile(filename)
-		{
+
-			Name: "root",
+	if err != nil {
-			Id: "akdjlask-23klaj2idalj2-ajl2kjd3i-2ldakjd2",
+		return nil, fmt.Errorf("Could not read config file: %s", err)
-			Peers: []Peer{
-				{ Id: "12D3KooWLF7BU5VgpqWdS1XwSTFCLphENozhYQAj6i5LqU8BPZZZ" },
-				{ Id: "12D3KooWBRvtW83QYnPgJCyVyAgMXtg71wjkGefVB2fBnm1A36kS" },
-				{ Id: "12D3KooWMmc4kYy78vSumqWtPkUNAoPeCpJ66ysFv1U8S554B7e2" },
-			},
-		},
-		{
-			Name: "foo",
-			Id: "2-903djl1290djl1-21jdl1kjd2-1d1jdl1k2jd11",
-			Peers: []Peer{
-				{ Id: "12D3KooWLF7BU5VgpqWdS1XwSTFCLphENozhYQAj6i5LqU8BPZZZ" },
-				{ Id: "12D3KooWMmc4kYy78vSumqWtPkUNAoPeCpJ66ysFv1U8S554B7e2" },
-			},
-		},
-		{
-			Name: "bar",
-			Id: "2-90ssssssssdjl1-21jdl1kjd2-1d1jdl1k2jd11",
-			Peers: []Peer{
-				//{ Id: "12D3KooWLF7BU5VgpqWdS1XwSTFCLphENozhYQAj6i5LqU8BPZZZ" },
-				//{ Id: "12D3KooWBRvtW83QYnPgJCyVyAgMXtg71wjkGefVB2fBnm1A36kS" },
-			},
-		},
 	}
+
+	var result []NamespaceConfig
+	err = json.Unmarshal(content, &result)
+
+
+	if err != nil {
+		return nil, fmt.Errorf("Could not parse config file: %s", err)
+	}
+
+	return result, nil
 }
 
 
@@ -182,11 +171,9 @@ func (wg *WhitelistConnectionGater) InterceptUpgraded(conn network.Conn) (allow
 	return wg.InterceptPeerDial(conn.RemotePeer()), 0
 }
 
-func GetTrustedPeers() map[string][]Peer {
+func GetTrustedPeers(config []NamespaceConfig) map[string][]Peer {
-	cfg := NewConfig()
-
 	result := make(map[string][]Peer)
-	for _, c := range cfg {
+	for _, c := range config {
 		result[c.Id] = c.Peers
 	}
 
@@ -204,9 +191,20 @@ type Namespace struct {
 	CancelFunc context.CancelFunc
 	ctx context.Context
 	Key *agelib.X25519Identity
+	TrustedPeers []Peer
 }
 
 
+func (n *Namespace) GetRecipients() []string {
+	var result []string
+
+	for _, peer := range n.TrustedPeers {
+		result = append(result, peer.Key)
+	}
+
+	return result
+}
+
 func (n *Namespace) Put(k string, v string) error {
 	key := ds.NewKey(k)
 	err := n.Datastore.Put(n.ctx, key, []byte(v))
@@ -253,6 +251,42 @@ func (n *Namespace) List() {
 	}
 }
 
+func (n *Namespace) GetAllPasswords() ([]password.Password, error) {
+	q := query.Query{}
+	results, err := n.Datastore.Query(n.ctx, q)
+
+	if err != nil {
+		return nil, fmt.Errorf("Error during GetAllPasswords: %s", err)
+	}
+
+	var result []password.Password
+
+	for r := range results.Next() {
+		if r.Error != nil {
+			printErr(err)
+			continue
+		}
+
+		val, err := age.Decrypt(r.Value, n.Key)
+
+		if err != nil {
+			printErr(err)
+			continue
+		}
+
+		pw, err := password.GetPasswordFromJson(val)
+
+		if err != nil {
+			printErr(err)
+			continue
+		}
+
+		result = append(result, pw)
+	}
+
+	return result, nil
+}
+
 func (n *Namespace) Close() {
 	n.Datastore.Close()
 	n.CancelFunc()
@@ -265,10 +299,31 @@ type StorageHandler struct {
 	Ipfs *ipfslite.Peer
 	PubSub *pubsub.PubSub
 	Key *agelib.X25519Identity
+	Config []NamespaceConfig
+	Namespaces map[string]*Namespace
 }
 
-func IsTrustedPeer(ctx context.Context, id peer.ID, namespace string) bool {
+func (s *StorageHandler) GetDefaultNamespace(Name string) *Namespace {
-	peerMap := GetTrustedPeers()
+	return s.Namespaces["root"]
+}
+
+func (s *StorageHandler) InitNamespaces() {
+	NamespaceMap := make(map[string]*Namespace)
+	for _, nsCfg := range s.Config {
+		ns1, err := CreateNamespace(nsCfg.Id, *s)
+
+		if err != nil {
+			logger.Fatal(err)
+		}
+
+		NamespaceMap[nsCfg.Name] = ns1
+	}
+
+	s.Namespaces = NamespaceMap
+}
+
+func IsTrustedPeer(ctx context.Context, id peer.ID, namespace string, config []NamespaceConfig) bool {
+	peerMap := GetTrustedPeers(config)
 
 	val, ok := peerMap[namespace]
 
@@ -299,7 +354,7 @@ func CreateNamespace(ID string, storageHandler StorageHandler) (*Namespace, erro
 		ID, //== topicName
 		func(ctx context.Context, _ peer.ID, msg *pubsub.Message) bool {
 			signer := msg.GetFrom()
-			trusted := IsTrustedPeer(ctx, signer, ID)
+			trusted := IsTrustedPeer(ctx, signer, ID, storageHandler.Config)
 			if !trusted {
 				logger.Debug("discarded pubsub message from non trusted source %s ", signer)
 			}
@@ -334,7 +389,15 @@ func CreateNamespace(ID string, storageHandler StorageHandler) (*Namespace, erro
 		return nil, err
 	}
 
-	return &Namespace{ID: ID, Datastore: crdt, CancelFunc: psubCancel, ctx: storageHandler.Ctx, Key: storageHandler.Key}, nil
+	PeerMap := GetTrustedPeers(storageHandler.Config)
+
+	val, ok := PeerMap[ID]
+
+	if !ok {
+		logger.Fatal("namespace config does not contain any peers")
+	}
+
+	return &Namespace{ID: ID, Datastore: crdt, CancelFunc: psubCancel, ctx: storageHandler.Ctx, Key: storageHandler.Key, TrustedPeers: val}, nil
 }
 
 
@@ -402,7 +465,7 @@ func DiscoverPeers(ctx context.Context, h host.Host, dht *dht.IpfsDHT) {
 	fmt.Printf("Own Id: %s\n", h.ID())
 	for !anyConnected {
 		time.Sleep(2 * time.Second)
-		fmt.Println("Searching for peers...")
+		//debug fmt.Println("Searching for peers...")
 		peerChan, err := routingDiscovery.FindPeers(ctx, topicNameFlag)
 		if err != nil {
 			panic(err)
@@ -413,7 +476,7 @@ func DiscoverPeers(ctx context.Context, h host.Host, dht *dht.IpfsDHT) {
 			}
 			err := h.Connect(ctx, peer)
 			if err != nil {
-				fmt.Printf("Failed connecting to %s, error: %s\n", peer.ID, err)
+				//debug fmt.Printf("Failed connecting to %s, error: %s\n", peer.ID, err)
 			} else {
 				fmt.Println("Connected to:", peer.ID)
 				anyConnected = true
@@ -425,7 +488,6 @@ func DiscoverPeers(ctx context.Context, h host.Host, dht *dht.IpfsDHT) {
 
 func printErr(err error) {
 	fmt.Println("error:", err)
-	fmt.Println("> ")
 }
 
 func ConnectedPeers(h host.Host) []*peer.AddrInfo {