signing

package
v0.4.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 14, 2023 License: Apache-2.0 Imports: 29 Imported by: 0

Documentation

Index

Constants

View Source 
const DECRYPTION_PREFIX = "decrypt:"
View Source 
const KIND_DECRYPTION_KEY = "decryption key"

Variables

This section is empty.

Functions

func BaseRootPool 

func BaseRootPool() (*x509.CertPool, error)

func CreateAndVerifyX509Certificate 

func CreateAndVerifyX509Certificate(cert, intermediateCAsCerts, rootCACert []byte) (*x509.Certificate, error)

CreateAndVerifyX509Certificate creates and verifies a x509 certificate from in-memory raw certificates. The certificates must be in PEM format.

func CreateAndVerifyX509CertificateFromFiles 

func CreateAndVerifyX509CertificateFromFiles(certPath, intermediateCAsCertsPath, rootCACertPath string) (*x509.Certificate, error)

CreateAndVerifyX509CertificateFromFiles creates and verifies a x509 certificate from certificate files. The certificates must be in PEM format.

func CreateCertificate 

func CreateCertificate(subject pkix.Name, validFrom *time.Time, validity time.Duration,
	pub interface{}, ca *x509.Certificate, priv interface{}, isCA bool, names ...string,
) ([]byte, error)

func DecryptionKeyName added in v0.4.1 

func DecryptionKeyName(name string) string

func GetCertificate 

func GetCertificate(data interface{}) (*x509.Certificate, error)

func Hash 

func Hash(hash hash.Hash, data []byte) (string, error)

func IntermediatePool 

func IntermediatePool(pemfile string, fss ...vfs.FileSystem) (*x509.CertPool, error)

func IsLegacyHashAlgorithm added in v0.3.0 

func IsLegacyHashAlgorithm(algo string) bool

func LegacyHashAlgorithm added in v0.3.0 

func LegacyHashAlgorithm(algo string) string

func Normalize 

func Normalize(n Normalization, v interface{}, ex ExcludeRules) ([]byte, error)

func NormalizeHashAlgorithm 

func NormalizeHashAlgorithm(algo string) string

func ParseCertificate 

func ParseCertificate(data []byte) (*x509.Certificate, error)

func ParsePrivateKey 

func ParsePrivateKey(data []byte) (interface{}, error)

func ParsePublicKey 

func ParsePublicKey(data []byte) (interface{}, error)

func ResolvePrivateKey added in v0.4.1 

func ResolvePrivateKey(reg KeyRegistryFuncs, name string) (interface{}, error)

func RootPool 

func RootPool(pemfile string, useOS bool, fss ...vfs.FileSystem) (*x509.CertPool, error)

func VerifyCert 

func VerifyCert(intermediate, root *x509.CertPool, cn string, cert *x509.Certificate) error

Types

type ArrayExcludes 

type ArrayExcludes struct {
	Continue ExcludeRules
}

func (ArrayExcludes) Element 

func (r ArrayExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (ArrayExcludes) Field 

func (r ArrayExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type ConditionalArrayExcludes added in v0.3.0 

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

func (ConditionalArrayExcludes) Check added in v0.3.0 

func (r ConditionalArrayExcludes) Check(value interface{}) ExcludeRules

func (ConditionalArrayExcludes) Element added in v0.3.0 

func (r ConditionalArrayExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (ConditionalArrayExcludes) Field added in v0.3.0 

func (r ConditionalArrayExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type ConditionalExclude added in v0.3.0 

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

func (ConditionalExclude) Check added in v0.3.0 

func (r ConditionalExclude) Check(value interface{}) ExcludeRules

type ConditionalMapExcludes added in v0.3.0 

type ConditionalMapExcludes map[string]*ConditionalExclude

func (ConditionalMapExcludes) Element added in v0.3.0 

func (r ConditionalMapExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (ConditionalMapExcludes) Field added in v0.3.0 

func (r ConditionalMapExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type DefaultedListEntries added in v0.3.0 

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

func (DefaultedListEntries) Element added in v0.3.0 

func (r DefaultedListEntries) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (DefaultedListEntries) Field added in v0.3.0 

func (r DefaultedListEntries) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type DefaultedMapFields added in v0.3.0 

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
}

DefaultedMapFields can be used to default map fields in maps or lists. For map entries the Name field must be set to the fieldname to default. For list entries the Name field is ignored.

func (DefaultedMapFields) Element added in v0.3.0 

func (r DefaultedMapFields) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (DefaultedMapFields) EnforceEmptyList added in v0.3.0 

func (r DefaultedMapFields) EnforceEmptyList(fields ...string) DefaultedMapFields

func (DefaultedMapFields) EnforceEmptyMap added in v0.3.0 

func (r DefaultedMapFields) EnforceEmptyMap(fields ...string) DefaultedMapFields

func (DefaultedMapFields) EnforceNull added in v0.3.0 

func (r DefaultedMapFields) EnforceNull(fields ...string) DefaultedMapFields

func (DefaultedMapFields) Field added in v0.3.0 

func (r DefaultedMapFields) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type DynamicArrayExcludes 

type DynamicArrayExcludes struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
}

func (DynamicArrayExcludes) Check 

func (r DynamicArrayExcludes) Check(value interface{}) bool

func (DynamicArrayExcludes) Element 

func (r DynamicArrayExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (DynamicArrayExcludes) Field 

func (r DynamicArrayExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type DynamicExclude 

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

func (*DynamicExclude) Check 

func (r *DynamicExclude) Check(value interface{}) bool

type DynamicInclude 

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

func (*DynamicInclude) Check 

func (r *DynamicInclude) Check(value interface{}) bool

type DynamicMapExcludes 

type DynamicMapExcludes map[string]*DynamicExclude

func (DynamicMapExcludes) Element 

func (r DynamicMapExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (DynamicMapExcludes) Field 

func (r DynamicMapExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type DynamicMapIncludes 

type DynamicMapIncludes map[string]*DynamicInclude

func (DynamicMapIncludes) Element 

func (r DynamicMapIncludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (DynamicMapIncludes) Field 

func (r DynamicMapIncludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type ExcludeEmpty 

type ExcludeEmpty struct {
	ExcludeRules
}

func (ExcludeEmpty) Element 

func (e ExcludeEmpty) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (ExcludeEmpty) Field 

func (e ExcludeEmpty) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

func (ExcludeEmpty) Filter 

func (ExcludeEmpty) Filter(v Normalized) (Normalized, error)

type ExcludeRules 

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

ExcludeRules defines the rules for normalization excludes.

type HandlerRegistry 

type HandlerRegistry interface {
	HandlerRegistryFuncs
	Copy() HandlerRegistry
}

func DefaultHandlerRegistry 

func DefaultHandlerRegistry() HandlerRegistry

func NewHandlerRegistry 

func NewHandlerRegistry(parents ...HandlerRegistry) HandlerRegistry

type HandlerRegistryFuncs added in v0.4.1 

type HandlerRegistryFuncs interface {
	SignerRegistryFuncs
	HasherRegistryFuncs

	SignerRegistryProvider
	HasherRegistryProvider
}

type HandlerRegistryProvider added in v0.4.1 

type HandlerRegistryProvider interface {
	HandlerRegistry() HandlerRegistry
}

type Hasher 

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

Hasher creates a new hash.Hash interface.

type HasherProvider added in v0.4.1 

type HasherProvider interface {
	GetHasher(name string) Hasher
}

type HasherRegistry added in v0.4.1 

type HasherRegistry interface {
	HasherRegistryFuncs

	Copy() HasherRegistry
}

func NewHasherRegistry added in v0.4.1 

func NewHasherRegistry(parents ...HasherRegistry) HasherRegistry

type HasherRegistryFuncs added in v0.4.1 

type HasherRegistryFuncs interface {
	HasherProvider

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

type HasherRegistryProvider added in v0.4.1 

type HasherRegistryProvider interface {
	HasherRegistry() HasherRegistry
}

type KeyRegistry 

type KeyRegistry interface {
	KeyRegistryFuncs
	Copy() KeyRegistry
}

func DefaultKeyRegistry 

func DefaultKeyRegistry() KeyRegistry

func NewKeyRegistry 

func NewKeyRegistry(parents ...KeyRegistry) KeyRegistry

type KeyRegistryFuncs added in v0.4.1 

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

	HasKeys() bool
}

type KeyRegistryProvider added in v0.4.1 

type KeyRegistryProvider interface {
	KeyRegistry() KeyRegistry
}

type MapExcludes 

type MapExcludes map[string]ExcludeRules

func (MapExcludes) Element 

func (r MapExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (MapExcludes) Field 

func (r MapExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type MapIncludes 

type MapIncludes map[string]ExcludeRules

func (MapIncludes) Element 

func (r MapIncludes) Element(v interface{}) (bool, interface{}, ExcludeRules)

func (MapIncludes) Field 

func (r MapIncludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type MapValue added in v0.4.0 

type MapValue struct {
	Mapping  ValueMapper
	Continue ExcludeRules
}

func (MapValue) Element added in v0.4.0 

func (m MapValue) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (MapValue) Field added in v0.4.0 

func (m MapValue) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

func (MapValue) MapValue added in v0.4.0 

func (m MapValue) MapValue(value interface{}) interface{}

type NoExcludes 

type NoExcludes struct{}

func (NoExcludes) Element 

func (r NoExcludes) Element(value interface{}) (bool, interface{}, ExcludeRules)

func (NoExcludes) Field 

func (r NoExcludes) Field(name string, value interface{}) (string, interface{}, ExcludeRules)

type Normalization added in v0.3.0 

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

	String() string
}

type NormalizationFilter 

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

type Normalized 

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)
}
var Null Normalized = (*null)(nil)

func Prepare 

func Prepare(n Normalization, v interface{}, ex ExcludeRules) (r Normalized, err error)

func PrepareNormalization 

func PrepareNormalization(n Normalization, v interface{}, excludes ExcludeRules) (Normalized, error)

type Registry 

type Registry interface {
	HandlerRegistryFuncs
	KeyRegistryFuncs

	HandlerRegistryProvider
	KeyRegistryProvider

	Copy() Registry
}

func DefaultRegistry 

func DefaultRegistry() Registry

func NewRegistry 

func NewRegistry(h HandlerRegistry, k KeyRegistry) Registry

func RegistryWithPreferredKeys added in v0.4.1 

func RegistryWithPreferredKeys(reg Registry, keys KeyRegistry) Registry

type Signature 

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

func (*Signature) String 

func (s *Signature) String() string

type SignatureHandler 

type SignatureHandler interface {
	Algorithm() string
	Signer
	Verifier
}

SignatureHandler can create and verify signature of a dedicated type.

type Signer 

type Signer interface {
	// Sign returns the signature for the given digest
	Sign(cctx credentials.Context, digest string, hash crypto.Hash, issuer string, privatekey interface{}) (*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
}

Signer interface is used to implement different signing algorithms. Each Signer should have a matching Verifier.

type SignerRegistry added in v0.4.1 

type SignerRegistry interface {
	SignerRegistryFuncs

	Copy() SignerRegistry
}

func NewSignerRegistry added in v0.4.1 

func NewSignerRegistry(parents ...SignerRegistry) SignerRegistry

type SignerRegistryFuncs added in v0.4.1 

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 added in v0.4.1 

type SignerRegistryProvider interface {
	SignerRegistry() SignerRegistry
}

type ValueChecker 

type ValueChecker func(value interface{}) bool

type ValueMapper 

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

type ValueMappingRule added in v0.4.0 

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

ValueMappingRule is an optional interface to implement to map a value before it is applied to the actual rule.

type Verifier 

type Verifier interface {
	// Verify checks the signature, returns an error on verification failure
	Verify(digest string, hash crypto.Hash, sig *Signature, publickey interface{}) error
	Algorithm() string
}

Verifier interface is used to implement different verification algorithms. Each Verifier should have a matching Signer.

Source Files

View all Source files

Directories

Path Synopsis
rsa
rsa-signingservice
sigstore
sigstore/attr
nodigest
sha256
sha512
norm
entry
jcs

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.