signing

type ArrayExcludes struct {
	Continue ExcludeRules
}

type ConditionalArrayExcludes struct {
	ValueChecker  ValueChecker
	ValueMapper   ValueMapper
	ContinueTrue  ExcludeRules
	ContinueFalse ExcludeRules
}

type ConditionalExclude struct {
	ValueChecker  ValueChecker
	ValueMapper   ValueMapper
	ContinueTrue  ExcludeRules
	ContinueFalse ExcludeRules
	Name          string
}

type ConditionalMapExcludes map[string]*ConditionalExclude

type DefaultSigningContext struct {
	Hash       crypto.Hash
	PrivateKey signutils.GenericPrivateKey
	PublicKey  signutils.GenericPublicKey
	RootCerts  signutils.GenericCertificatePool
	Issuer     *pkix.Name
}

type DefaultedListEntries struct {
	Default  interface{}
	Continue ExcludeRules
	Next     ExcludeRules
}

type DefaultedMapFields struct {
	// Name of the field for map entries, for lists this field must be left blank.
	Name     string
	Fields   map[string]interface{}
	Continue ExcludeRules
	Next     ExcludeRules
}

type DynamicArrayExcludes struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
}

type DynamicExclude struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
	Name         string
}

type DynamicInclude struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
	Name         string
}

type DynamicMapExcludes map[string]*DynamicExclude

type DynamicMapIncludes map[string]*DynamicInclude

type ExcludeEmpty struct {
	ExcludeRules
}

type ExcludeRules interface {
	Field(name string, value interface{}) (string, interface{}, ExcludeRules)
	Element(v interface{}) (bool, interface{}, ExcludeRules)
}

type HandlerRegistry interface {
	HandlerRegistryFuncs
	Copy() HandlerRegistry
}

type HandlerRegistryFuncs interface {
	SignerRegistryFuncs
	HasherRegistryFuncs

	SignerRegistryProvider
	HasherRegistryProvider
}

type HandlerRegistryProvider interface {
	HandlerRegistry() HandlerRegistry
}

type Hasher interface {
	Algorithm() string
	Create() hash.Hash
	Crypto() crypto.Hash
}

type HasherProvider interface {
	GetHasher(name string) Hasher
}

type HasherRegistry interface {
	HasherRegistryFuncs

	Copy() HasherRegistry
}

type HasherRegistryFuncs interface {
	HasherProvider

	RegisterHasher(hasher Hasher)
	HasherNames() []string
}

type HasherRegistryProvider interface {
	HasherRegistry() HasherRegistry
}

type KeyRegistry interface {
	KeyRegistryFuncs
	Copy() KeyRegistry
}

type KeyRegistryFuncs interface {
	RegisterPublicKey(name string, key interface{})
	RegisterPrivateKey(name string, key interface{})
	GetPublicKey(name string) interface{}
	GetPrivateKey(name string) interface{}
	HasKeys() bool

	RegisterIssuer(name string, is *pkix.Name)
	GetIssuer(name string) *pkix.Name
	HasIssuers() bool
}

type KeyRegistryProvider interface {
	KeyRegistry() KeyRegistry
}

type MapExcludes map[string]ExcludeRules

type MapIncludes map[string]ExcludeRules

type MapValue struct {
	Mapping  ValueMapper
	Continue ExcludeRules
}

type NoExcludes struct{}

type Normalization interface {
	NewArray() Normalized
	NewMap() Normalized
	NewValue(v interface{}) Normalized

	String() string
}

type NormalizationFilter interface {
	Filter(Normalized) (Normalized, error)
}

type Normalized interface {
	Value() interface{}
	IsEmpty() bool
	Marshal(gap string) ([]byte, error)

	ToString(gap string) string
	String() string
	Formatted() string

	Append(Normalized)
	SetField(name string, value Normalized)
}

type Registry interface {
	RegistryFuncs

	Copy() Registry
}

type RegistryFuncs interface {
	HandlerRegistryFuncs
	KeyRegistryFuncs

	HandlerRegistryProvider
	KeyRegistryProvider

	TSAUrl() string
	SetTSAUrl(url string)
}

type Signature struct {
	Value     string
	MediaType string
	Algorithm string
	Issuer    string
}

type SignatureHandler interface {
	Algorithm() string
	Signer
	Verifier
}

type Signer interface {
	// Sign returns the signature for the given digest.
	// If known a given public key can be passed. The signer may
	// decide to put a trusted public key into the signature,
	// for example for public keys provided by organization validated
	// certificates.
	// If used the key and/or certificate must be validated, for certificates
	// the distinguished name must match the issuer.
	Sign(cctx credentials.Context, digest string, sctx SigningContext) (*Signature, error)
	// Algorithm is the name of the finally used signature algorithm.
	// A signer might be registered using a logical name, so there might
	// be multiple signer registration providing the same signature algorithm
	Algorithm() string
}

type SignerRegistry interface {
	SignerRegistryFuncs

	Copy() SignerRegistry
}

type SignerRegistryFuncs interface {
	RegisterSignatureHandler(handler SignatureHandler)
	RegisterSigner(algo string, signer Signer)
	RegisterVerifier(algo string, verifier Verifier)
	GetSigner(name string) Signer
	GetVerifier(name string) Verifier
	SignerNames() []string
}

type SignerRegistryProvider interface {
	SignerRegistry() SignerRegistry
}

type SigningContext interface {
	GetHash() crypto.Hash
	GetPrivateKey() signutils.GenericPrivateKey
	GetPublicKey() signutils.GenericPublicKey
	GetRootCerts() signutils.GenericCertificatePool
	GetIssuer() *pkix.Name
}

type ValueChecker func(value interface{}) bool

type ValueMapper func(v interface{}) interface{}

type ValueMappingRule interface {
	MapValue(v interface{}) interface{}
}

type Verifier interface {
	// Verify checks the signature, returns an error on verification failure
	Verify(digest string, sig *Signature, sctx SigningContext) error
	Algorithm() string
}