140 lines
2.6 KiB
Go
140 lines
2.6 KiB
Go
package rpc
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
"net/rpc"
|
|
"net/http"
|
|
|
|
"os"
|
|
"os/signal"
|
|
"syscall"
|
|
|
|
"github.com/k4lipso/pentapass/storage"
|
|
"github.com/k4lipso/pentapass/crypto"
|
|
"github.com/k4lipso/pentapass/crypto/age"
|
|
)
|
|
|
|
var StorageHandler *storage.StorageHandler
|
|
|
|
type Query int
|
|
|
|
type NamespaceService struct {
|
|
Namespace string
|
|
Service string
|
|
}
|
|
|
|
func (t *Query) Generate(np *NamespaceService, reply *crypto.Password) error {
|
|
val, ok := StorageHandler.Namespaces[np.Namespace]
|
|
|
|
if !ok {
|
|
return fmt.Errorf("Namespace does not exist")
|
|
}
|
|
|
|
password := crypto.NewPassword(crypto.DEFAULT_LENGTH)
|
|
password.Service = np.Service
|
|
|
|
data, err := password.ToJson()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
encryptedPassword, err := age.Encrypt(data, val.GetRecipients())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
err = val.Put(password.Service, string(encryptedPassword))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
*reply = *password
|
|
return nil
|
|
}
|
|
|
|
func (t *Query) Get(np *NamespaceService, reply *crypto.Password) error {
|
|
namespace := np.Namespace
|
|
val, ok := StorageHandler.Namespaces[namespace]
|
|
|
|
if !ok {
|
|
return fmt.Errorf("Namespace does not exist")
|
|
}
|
|
|
|
v, err := val.GetPassword(np.Service)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
*reply = v
|
|
return nil
|
|
}
|
|
|
|
//func (t *Query) Add(password *crypto.Password, reply *[]string) error {
|
|
// return nil
|
|
//}
|
|
|
|
func (t *Query) Delete(np *NamespaceService, success *bool) error {
|
|
namespace := np.Namespace
|
|
val, ok := StorageHandler.Namespaces[namespace]
|
|
|
|
if !ok {
|
|
return fmt.Errorf("Namespace does not exist")
|
|
}
|
|
|
|
err := val.Delete(np.Service)
|
|
if err != nil {
|
|
*success = false
|
|
return err
|
|
}
|
|
|
|
*success = true
|
|
return nil
|
|
}
|
|
|
|
func (t *Query) GetAllNames(namespace *string, reply *[]string) error {
|
|
fmt.Println("RPC Request: Query::LoadedTriggers")
|
|
fmt.Printf("Listing content of %s", *namespace)
|
|
|
|
val, ok := StorageHandler.Namespaces[*namespace]
|
|
|
|
if !ok {
|
|
return fmt.Errorf("Namesapce does not exist")
|
|
}
|
|
|
|
*reply = val.GetAllNames()
|
|
return nil
|
|
}
|
|
|
|
func Serve(path string) {
|
|
query := new(Query)
|
|
rpc.Register(query)
|
|
rpc.HandleHTTP()
|
|
l, err := net.Listen("unix", path + "/rpc_test.socket")
|
|
|
|
if err != nil {
|
|
fmt.Printf("Error while listening on unix socket: %s\n", err)
|
|
}
|
|
|
|
go http.Serve(l, nil)
|
|
|
|
sigc := make(chan os.Signal, 1)
|
|
signal.Notify(sigc, os.Interrupt, syscall.SIGTERM)
|
|
func(ln net.Listener, c chan os.Signal) {
|
|
sig := <-c
|
|
fmt.Printf("Caught signal %s: shutting down.\n", sig)
|
|
ln.Close()
|
|
os.Exit(0)
|
|
}(l, sigc)
|
|
}
|
|
|
|
func Receive(path string) (*rpc.Client, error) {
|
|
client, err := rpc.DialHTTP("unix", path + "/rpc_test.socket")
|
|
|
|
if err != nil {
|
|
fmt.Printf("Cant connect to RPC server: %s\n", err)
|
|
}
|
|
|
|
return client, err
|
|
}
|