Back to godoc.org
gopkg.in/macaroon-bakery.v2 / bakery / dbrootkeystore

Package dbrootkeystore

v2.2.0
Latest Go to latest
Published: Mar 4, 2020 | License: LGPL-3.0 | Module: gopkg.in/macaroon-bakery.v2

Overview

Package dbkeystore provides the underlying basis for a bakery.RootKeyStore that uses a database as a persistent store and provides flexible policies for root key storage lifetime.

Index

Package Files

type Backing

type Backing interface {
	// GetKey gets the key with the given id from the
	// backing store. If the key is not found, it should
	// return an error with a bakery.ErrNotFound cause.
	GetKey(id []byte) (RootKey, error)

	// FindLatestKey returns the most recently created root key k
	// such that all of the following conditions hold:
	//
	// 	k.Created >= createdAfter
	// 	k.Expires >= expiresAfter
	// 	k.Expires <= expiresBefore
	//
	// If no such key was found, the zero root key should be returned
	// with a nil error.
	FindLatestKey(createdAfter, expiresAfter, expiresBefore time.Time) (RootKey, error)

	// InsertKey inserts the given root key into the backing store.
	// It may return an error if the id or key already exist.
	InsertKey(key RootKey) error
}

Backing holds the interface used to store keys in the underlying database used as a backing store by RootKeyStore.

type Clock

type Clock interface {
	Now() time.Time
}

Clock can be used to provide a mockable time of day for testing.

type ContextBacking

type ContextBacking interface {
	// GetKeyContext gets the key with the given id from the backing
	// store. If the key is not found, it should return an error with
	// a bakery.ErrNotFound cause.
	GetKeyContext(ctx context.Context, id []byte) (RootKey, error)

	// FindLatestKeyContext returns the most recently created root
	// key k such that all of the following conditions hold:
	//
	// 	k.Created >= createdAfter
	// 	k.Expires >= expiresAfter
	// 	k.Expires <= expiresBefore
	//
	// If no such key was found, the zero root key should be returned
	// with a nil error.
	FindLatestKeyContext(ctx context.Context, createdAfter, expiresAfter, expiresBefore time.Time) (RootKey, error)

	// InsertKeyContext inserts the given root key into the backing
	// store. It may return an error if the id or key already exist.
	InsertKeyContext(ctx context.Context, key RootKey) error
}

A ContextBacking is like a Backing but all methods accept a context.Context. If a Backing also implements ContextBacking then the ContextBacking methods will be used in preference.

type Policy

type Policy struct {
	// GenerateInterval holds the maximum length of time
	// for which a root key will be returned from RootKey.
	// If this is zero, it defaults to ExpiryDuration.
	GenerateInterval time.Duration

	// ExpiryDuration holds the minimum length of time that
	// root keys will be valid for after they are returned from
	// RootKey. The maximum length of time that they
	// will be valid for is ExpiryDuration + GenerateInterval.
	ExpiryDuration time.Duration
}

Policy holds a store policy for root keys.

type RootKey

type RootKey struct {
	// Id holds the id of the root key.
	Id []byte `bson:"_id"`
	// Created holds the time that the root key was created.
	Created time.Time
	// Expires holds the time that the root key expires.
	Expires time.Time
	// RootKey holds the root key secret itself.
	RootKey []byte
}

RootKey is the type stored in the underlying database.

func (RootKey) IsValid

func (rk RootKey) IsValid() bool

IsValid reports whether the root key contains a key. Note that we always generate non-empty root keys, so we use this to find whether the root key is empty or not.

func (RootKey) IsValidWithPolicy

func (rk RootKey) IsValidWithPolicy(p Policy, now time.Time) bool

IsValidWithPolicy reports whether the given root key is valid to use at the given time with the given store policy.

type RootKeys

type RootKeys struct {
	// contains filtered or unexported fields
}

RootKeys represents a cache of macaroon root keys.

func NewRootKeys

func NewRootKeys(maxCacheSize int, clock Clock) *RootKeys

NewRootKeys returns a root-keys cache that is limited in size to approximately the given size.

The NewStore method returns a store implementation that uses specific store policy and backing database implementation.

If clock is non-nil, it will be used to find the current time, otherwise time.Now will be used.

func (*RootKeys) NewStore

func (s *RootKeys) NewStore(b Backing, policy Policy) bakery.RootKeyStore

NewStore returns a new RootKeyStore implementation that stores and obtains root keys from the given Backing. If the given Backing also implements ContextBacking, then the ContextBacking methods will be used in preference.

Root keys will be generated and stored following the given store policy.

It is expected that all Backing instances passed to a given Store's NewStore method should refer to the same underlying database.

Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier