credentials.go

// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package v23test

import (
	"io/ioutil"
	"path/filepath"

	"v.io/v23/security"
	libsec "v.io/x/ref/lib/security"
	"v.io/x/ref/services/agent/agentlib"
	"v.io/x/ref/services/agent/server"
)

// Credentials represents a principal with a set of blessings. It is designed to
// be implementable using either the filesystem (with a credentials dir) or the
// Vanadium security agent.
type Credentials struct {
	Handle    string
	Principal security.Principal // equal to pm.Principal(Handle)
}

// newCredentials creates a new Credentials.
func newCredentials(pm principalManager) (*Credentials, error) {
	h, err := pm.New()
	if err != nil {
		return nil, err
	}
	p, err := pm.Principal(h)
	if err != nil {
		return nil, err
	}
	return &Credentials{Handle: h, Principal: p}, nil
}

// newRootCredentials creates a new Credentials with a self-signed "root"
// blessing.
func newRootCredentials(pm principalManager) (*Credentials, error) {
	res, err := newCredentials(pm)
	if err != nil {
		return nil, err
	}
	if err := libsec.InitDefaultBlessings(res.Principal, "root"); err != nil {
		return nil, err
	}
	return res, nil
}

func addDefaultBlessings(self, other security.Principal, extensions ...string) error {
	for _, extension := range extensions {
		bself, _ := self.BlessingStore().Default()
		blessings, err := self.Bless(other.PublicKey(), bself, extension, security.UnconstrainedUse())
		if err != nil {
			return err
		}
		bother, _ := other.BlessingStore().Default()
		union, err := security.UnionOfBlessings(bother, blessings)
		if err != nil {
			return err
		}
		if err := libsec.SetDefaultBlessings(other, union); err != nil {
			return err
		}
	}
	return nil
}

////////////////////////////////////////////////////////////////////////////////
// principalManager interface and implementations

// principalManager manages principals.
type principalManager interface {
	// New creates a principal and returns a handle to it.
	New() (string, error)

	// Principal returns the principal for the given handle.
	Principal(handle string) (security.Principal, error)
}

////////////////////////////////////////
// filesystemPrincipalManager

type filesystemPrincipalManager struct {
	rootDir string
}

func newFilesystemPrincipalManager(rootDir string) principalManager {
	return &filesystemPrincipalManager{rootDir: rootDir}
}

func (pm *filesystemPrincipalManager) New() (string, error) {
	dir, err := ioutil.TempDir(pm.rootDir, "")
	if err != nil {
		return "", err
	}
	if _, err := libsec.CreatePersistentPrincipal(dir, nil); err != nil {
		return "", err
	}
	return dir, nil
}

func (m *filesystemPrincipalManager) Principal(handle string) (security.Principal, error) {
	return libsec.LoadPersistentPrincipal(handle, nil)
}

////////////////////////////////////////
// agentPrincipalManager

// agentPrincipalManager creates filesystem-based credentials, starts an agent
// per credentials directory, and passes back the agent socket file as the
// 'handle'.
//
// TODO(caprita): We should pass back the credentials directory itself as the
// handle, and not the socket: clients can use agentlib.LoadPrincipal to
// transparently find the socket and load the credentials.  However, some tests
// currently expect v23test.Shell to set V23_AGENT_PATH instead of
// V23_CREDENTIALS on the commands it starts, and we need to fix those tests
// first.

type agentPrincipalManager struct {
	rootDir string
}

func newAgentPrincipalManager(rootDir string) (principalManager, error) {
	return &agentPrincipalManager{rootDir: rootDir}, nil
}

func (pm *agentPrincipalManager) New() (string, error) {
	credsDir, err := ioutil.TempDir(pm.rootDir, "")
	if err != nil {
		return "", err
	}
	p, err := libsec.CreatePersistentPrincipal(credsDir, nil)
	if err != nil {
		return "", err
	}
	sockDir, err := ioutil.TempDir(pm.rootDir, "")
	if err != nil {
		return "", err
	}
	sockPath := filepath.Join(sockDir, "s")
	if _, err = server.Serve(p, sockPath); err != nil {
		return "", err
	}
	return sockPath, nil
}

func (m *agentPrincipalManager) Principal(handle string) (security.Principal, error) {
	return agentlib.NewAgentPrincipalX(handle)
}