object

Documentation

Index

• Constants
• func Sign(k crypto.PrivateKey, o *Object) error
• func SignDeep(k crypto.PrivateKey, o *Object) error
• func Traverse(v interface{}, f func(string, interface{}) bool)
• func Unmarshal(o *Object, out interface{}) error
• func Verify(o *Object) error
• type ByteMashaller
• type ByteUnmashaller
• type EvaluationResult
• type Getter
• type GetterFunc
• type MapMashaller
• type MapUnmashaller
• type Metadata
• type Object
  • func Copy(s *Object) *Object
  • func Marshal(in interface{}) (*Object, error)
  • func MustMarshal(in interface{}) *Object
  • func ReadAll(r Reader) ([]*Object, error)
  • func (o *Object) Hash() tilde.Digest
  • func (o *Object) MarshalJSON() ([]byte, error)
  • func (o *Object) MarshalMap() (tilde.Map, error)
  • func (o *Object) UnmarshalJSON(b []byte) error
  • func (o *Object) UnmarshalMap(v tilde.Map) error
• type Parents
  • func (ps Parents) All() []tilde.Digest
• type ParsedType
  • func ParseType(objectType string) ParsedType
• type Policies
  • func (ps Policies) Evaluate(subject crypto.PublicKey, resource string, action PolicyAction) EvaluationResult
• type Policy
  • func (p Policy) Evaluate(subject crypto.PublicKey, resource string, action PolicyAction) EvaluationResult
• type PolicyAction
• type PolicyEffect
• type PolicyType
• type ReadCloser
  • func NewReadCloser(ctx context.Context, objects <-chan *Object, errs <-chan error, ...) ReadCloser
  • func NewReadCloserFromObjects(objects []*Object) ReadCloser
• type Reader
• type Request
• type Response
• type Signature
  • func NewSignature(k crypto.PrivateKey, o *Object) (Signature, error)
  • func (s *Signature) IsEmpty() bool
• type StringMashaller
• type StringUnmashaller
• type Typer

Constants

const (
	// Policy types
	SignaturePolicy PolicyType = "signature"

	// Policy actions
	ReadAction PolicyAction = "read"

	// Policy effects
	AllowEffect PolicyEffect = "allow"
	DenyEffect  PolicyEffect = "deny"

	// Policy Evaluation results
	Deny  EvaluationResult = "deny"
	Allow EvaluationResult = "allow"
)

const (
	// ErrInvalidObjectType is returned when the signature being verified
	// is not an encoded object of type "signature".
	ErrInvalidObjectType = errors.Error("invalid object type")
	// ErrAlgorithNotImplemented is returned when the algorithm specified
	// has not been implemented
	ErrAlgorithNotImplemented = errors.Error("algorithm not implemented")
)

const (
	ErrInvalidSigner    = errors.Error("signer does not match owner")
	ErrMissingSignature = errors.Error("missing signature")
	ErrCouldNotVerify   = errors.Error("could not verify signature")
)

const (
	// AlgorithmObjectHash is the only supported signing algorithm right now.
	AlgorithmObjectHash = "EdDSA"
)

const (
	ErrReaderDone = errors.Error("reader done")
)

const RequestType = "nimona.io/Request"

const ResponseType = "nimona.io/Response"

Functions

func Sign

func Sign(k crypto.PrivateKey, o *Object) error

Sign an object given a private key, updates the object's metadata in place

func SignDeep

func SignDeep(k crypto.PrivateKey, o *Object) error

SignDeep an object and all nested objects we own or have no owner WARNING: THIS _WILL_ CHANGE, DO NOT USE! TODO: not sure which nested objects this should sign. All? Own?

func Traverse

func Traverse(v interface{}, f func(string, interface{}) bool)

func Unmarshal

func Unmarshal(o *Object, out interface{}) error

Unmarshal an object into a tagged struct

func Verify

func Verify(o *Object) error

Verify object TODO should this verify nested objects as well?

Types

type ByteMashaller

type ByteMashaller interface {
	MarshalBytes() ([]byte, error)
}

type ByteUnmashaller

type ByteUnmashaller interface {
	UnmarshalBytes([]byte) error
}

type EvaluationResult

type EvaluationResult string

type Getter

type Getter interface {
	Get(
		context.Context,
		tilde.Digest,
	) (*Object, error)
}

type GetterFunc

type GetterFunc func(
	context.Context,
	tilde.Digest,
) (*Object, error)

GetterFunc is an adapter to allow the use of ordinary functions as object.Getter

type MapMashaller

type MapMashaller interface {
	MarshalMap() (tilde.Map, error)
}

type MapUnmashaller

type MapUnmashaller interface {
	UnmarshalMap(tilde.Map) error
}

type Metadata

type Metadata struct {
	Owner     did.DID      `nimona:"owner:s"`
	Parents   Parents      `nimona:"parents:m"`
	Policies  Policies     `nimona:"policies:am"`
	Root      tilde.Digest `nimona:"root:r"`
	Sequence  uint64       `nimona:"sequence:u,omitzero"`
	Signature Signature    `nimona:"_signature:m"`
	Timestamp string       `nimona:"timestamp:s"`
}

Metadata for object TODO: add shape TODO: add authors, contributors, license, copyright TODO: add version

type Object

type Object struct {
	Context  tilde.Digest
	Type     string
	Metadata Metadata
	Data     tilde.Map
}

func Copy

func Copy(s *Object) *Object

func Marshal

func Marshal(in interface{}) (*Object, error)

func MustMarshal

func MustMarshal(in interface{}) *Object

func ReadAll

func ReadAll(r Reader) ([]*Object, error)

ReadAll is a helper method that

func (*Object) Hash

func (o *Object) Hash() tilde.Digest

func (*Object) MarshalJSON

func (o *Object) MarshalJSON() ([]byte, error)

func (*Object) MarshalMap

func (o *Object) MarshalMap() (tilde.Map, error)

func (*Object) UnmarshalJSON

func (o *Object) UnmarshalJSON(b []byte) error

func (*Object) UnmarshalMap

func (o *Object) UnmarshalMap(v tilde.Map) error

type Parents

type Parents map[string]tilde.DigestArray

func (Parents) All

func (ps Parents) All() []tilde.Digest

type ParsedType

type ParsedType struct {
	PrimaryType string
	Namespace   string
	Object      string
}

func ParseType

func ParseType(objectType string) ParsedType

type Policies

type Policies []Policy

Policies

func (Policies) Evaluate

func (ps Policies) Evaluate(
	subject crypto.PublicKey,
	resource string,
	action PolicyAction,
) EvaluationResult

type Policy

type Policy struct {
	Name      string             `nimona:"name:s"`
	Type      PolicyType         `nimona:"type:s"`
	Subjects  []crypto.PublicKey `nimona:"subjects:as"`
	Resources []string           `nimona:"resources:as"`
	Actions   []PolicyAction     `nimona:"actions:as"`
	Effect    PolicyEffect       `nimona:"effect:s"`
}

Policy for object metadata

func (Policy) Evaluate

func (p Policy) Evaluate(
	subject crypto.PublicKey,
	resource string,
	action PolicyAction,
) EvaluationResult

type PolicyAction

type PolicyAction string

type PolicyEffect

type PolicyEffect string

type PolicyType

type PolicyType string

type ReadCloser

type ReadCloser interface {
	Read() (*Object, error)
	Close()
}

func NewReadCloser

func NewReadCloser(
	ctx context.Context,
	objects <-chan *Object,
	errs <-chan error,
	closer chan<- struct{},
) ReadCloser

func NewReadCloserFromObjects

func NewReadCloserFromObjects(objects []*Object) ReadCloser

NewReadCloserFromObjects is mainly used for testing and mocks that return a Reader, or ReadCloser.

type Reader

type Reader interface {
	Read() (*Object, error)
}

type Request

type Request struct {
	Metadata   Metadata     `nimona:"@metadata:m,type=nimona.io/Request"`
	RequestID  string       `nimona:"requestID:s"`
	ObjectHash tilde.Digest `nimona:"objectHash:s"`
}

type Response

type Response struct {
	Metadata  Metadata `nimona:"@metadata:m,type=nimona.io/Response"`
	RequestID string   `nimona:"requestID:s"`
	Object    *Object  `nimona:"object:m"`
}

type Signature

type Signature struct {
	Delegator did.DID          `nimona:"d:s"`
	Signer    did.DID          `nimona:"s:s"`
	Key       crypto.PublicKey `nimona:"jwk:s"`
	Alg       string           `nimona:"alg:s"`
	X         []byte           `nimona:"x:d"`
	// contains filtered or unexported fields
}

func NewSignature

func NewSignature(
	k crypto.PrivateKey,
	o *Object,
) (Signature, error)

NewSignature returns a signature given some bytes and a private key

func (*Signature) IsEmpty

func (s *Signature) IsEmpty() bool

type StringMashaller

type StringMashaller interface {
	MarshalString() (string, error)
}

type StringUnmashaller

type StringUnmashaller interface {
	UnmarshalString(string) error
}

type Typer

type Typer interface {
	Type() string
}