handler

type AppraiseEvidenceArgs struct {
	Evidence     []byte
	Endorsements []string
}

type BadEvidenceError struct {
	Detail interface{}
}

type Endorsement struct {
	Scheme string `json:"scheme"`
	Type   string `json:"type"`

	SubType    string          `json:"subType"`
	Attributes json.RawMessage `json:"attributes"`
}

type EndorsementHandlerParams map[string]interface{}

type EndorsementHandlerResponse struct {
	ReferenceValues []Endorsement
	TrustAnchors    []Endorsement
}

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

type EndorsementRPCServer struct {
	Impl IEndorsementHandler
}

type ExtractClaimsArgs struct {
	Token        []byte
	TrustAnchors []string
}

type GetRefValueIDsArgs struct {
	TenantID     string
	TrustAnchors []string
	Claims       []byte
}

type IDecoderManager interface {
	Init(dir string, logger *zap.SugaredLogger) error
	Close() error
	Dispatch(mediaType string, data []byte) (*EndorsementHandlerResponse, error)
	IsSupportedMediaType(mediaType string) bool
	GetSupportedMediaTypes() []string
}

type IEndorsementHandler interface {
	plugin.IPluggable

	// Init() initializes the handler.
	Init(params EndorsementHandlerParams) error

	// Close the decoder, finalizing any state it may contain.
	Close() error

	// Decode the endorsements from the provided []byte.
	Decode([]byte) (*EndorsementHandlerResponse, error)
}

type IEvidenceHandler interface {
	plugin.IPluggable

	// ExtractClaims parses the attestation token and returns claims
	// extracted therefrom.
	ExtractClaims(
		token *proto.AttestationToken,
		trustAnchors []string,
	) (map[string]interface{}, error)

	// ValidateEvidenceIntegrity verifies the structural integrity and validity of the
	// token. The exact checks performed are scheme-specific, but they
	// would typically involve, at the least, verifying the token's
	// signature using the provided trust anchors and endorsements. If the
	// validation fails, an error detailing what went wrong is returned.
	// Note: key material required to  validate the token would typically be
	//       provisioned as a Trust Anchor. However, depending on the
	//       requirements of the Scheme, it maybe be provisioned as an
	//       Endorsement instead, or in addition to the Trust Anchor. E.g.,
	//       if the validation is performed via an x.509 cert chain, the
	//       root cert may be provisioned as a Trust Anchor, while
	//       intermediate certs may be provisioned as Endorsements (at a
	//       different point in time, by a different actor).
	// TODO(setrofim): no distinction is currently made between validation
	// failing due to an internal error, and it failing due to bad input
	// (i.e. signature not matching).
	ValidateEvidenceIntegrity(
		token *proto.AttestationToken,
		trustAnchors []string,
		endorsementsStrings []string,
	) error

	// AppraiseEvidence evaluates the specified EvidenceContext against
	// the specified endorsements, and returns an AttestationResult.
	AppraiseEvidence(
		ec *proto.EvidenceContext,
		endorsements []string,
	) (*ear.AttestationResult, error)
}

type IStoreHandler interface {
	plugin.IPluggable

	// GetTrustAnchorIDs returns a slice of trust anchor identifiers used
	// to retrieve the trust anchors associated with this token. The trust anchors may be necessary to validate the
	// entire token and/or extract its claims (if it is encrypted).
	GetTrustAnchorIDs(token *proto.AttestationToken) ([]string, error)

	// GetRefValueIDs returns a slice of identifiers used to retrieve
	// reference values for an attestation scheme, using the claims
	// extracted from attestation token and the associated trust anchors.
	GetRefValueIDs(
		tenantID string,
		trustAnchors []string,
		claims map[string]interface{},
	) ([]string, error)

	// SynthKeysFromRefValue synthesizes lookup key(s) for the
	// provided reference value endorsement.
	SynthKeysFromRefValue(tenantID string, refVal *Endorsement) ([]string, error)

	// SynthKeysFromTrustAnchor synthesizes lookup key(s) for the provided
	// trust anchor.
	SynthKeysFromTrustAnchor(tenantID string, ta *Endorsement) ([]string, error)
}

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

type RPCServer struct {
	Impl IEvidenceHandler
}

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

type StoreRPCServer struct {
	Impl IStoreHandler
}

type SynthKeysArgs struct {
	TenantID        string
	EndorsementJSON []byte
}

type ValidateEvidenceIntegrityArgs struct {
	Token        []byte
	TrustAnchors []string
	Endorsements []string
}