signing

package
v0.15.0 Latest Latest
Warning

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

 Go to latest Published: Sep 13, 2024 License: Apache-2.0 Imports: 23 Imported by: 0

Documentation

Index

Constants

View Source 
const DECRYPTION_PREFIX = "decrypt:"
View Source 
const DEFAULT_TSA_URL = "http://timestamp.digicert.com"
View Source 
const KIND_DECRYPTION_KEY = "decryption key"

Variables

This section is empty.

Functions

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 DecryptionKeyName 

func DecryptionKeyName(name string) string

func Hash 

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

func IsLegacyHashAlgorithm 

func IsLegacyHashAlgorithm(algo string) bool

func LegacyHashAlgorithm 

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 ResolvePrivateKey 

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

func VerifyCert 

func VerifyCert(intermediate signutils.GenericCertificateChain, root signutils.GenericCertificatePool, name string, cert *x509.Certificate) error

func VerifyCertDN 

func VerifyCertDN(intermediate signutils.GenericCertificateChain, root signutils.GenericCertificatePool, name *pkix.Name, 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 

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

func (ConditionalArrayExcludes) Check 

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

func (ConditionalArrayExcludes) Element 

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

func (ConditionalArrayExcludes) Field 

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

type ConditionalExclude 

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

func (ConditionalExclude) Check 

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

type ConditionalMapExcludes 

type ConditionalMapExcludes map[string]*ConditionalExclude

func (ConditionalMapExcludes) Element 

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

func (ConditionalMapExcludes) Field 

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

type DefaultSigningContext 

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

func (*DefaultSigningContext) GetHash 

func (d *DefaultSigningContext) GetHash() crypto.Hash

func (*DefaultSigningContext) GetIssuer 

func (d *DefaultSigningContext) GetIssuer() *pkix.Name

func (*DefaultSigningContext) GetPrivateKey 

func (d *DefaultSigningContext) GetPrivateKey() signutils.GenericPrivateKey

func (*DefaultSigningContext) GetPublicKey 

func (d *DefaultSigningContext) GetPublicKey() signutils.GenericPublicKey

func (*DefaultSigningContext) GetRootCerts 

func (d *DefaultSigningContext) GetRootCerts() signutils.GenericCertificatePool

type DefaultedListEntries 

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

func (DefaultedListEntries) Element 

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

func (DefaultedListEntries) Field 

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

type DefaultedMapFields 

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 

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

func (DefaultedMapFields) EnforceEmptyList 

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

func (DefaultedMapFields) EnforceEmptyMap 

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

func (DefaultedMapFields) EnforceNull 

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

func (DefaultedMapFields) Field 

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 

type HandlerRegistryFuncs interface {
	SignerRegistryFuncs
	HasherRegistryFuncs

	SignerRegistryProvider
	HasherRegistryProvider
}

type HandlerRegistryProvider 

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 

type HasherProvider interface {
	GetHasher(name string) Hasher
}

type HasherRegistry 

type HasherRegistry interface {
	HasherRegistryFuncs

	Copy() HasherRegistry
}

func NewHasherRegistry 

func NewHasherRegistry(parents ...HasherRegistry) HasherRegistry

type HasherRegistryFuncs 

type HasherRegistryFuncs interface {
	HasherProvider

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

type HasherRegistryProvider 

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 

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 

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 

type MapValue struct {
	Mapping  ValueMapper
	Continue ExcludeRules
}

func (MapValue) Element 

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

func (MapValue) Field 

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

func (MapValue) MapValue 

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 

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 {
	RegistryFuncs

	Copy() Registry
}

func DefaultRegistry 

func DefaultRegistry() Registry

func NewRegistry 

func NewRegistry(h HandlerRegistry, k KeyRegistry) Registry

func RegistryWithPreferredKeys 

func RegistryWithPreferredKeys(reg Registry, keys KeyRegistry) Registry

type RegistryFuncs 

type RegistryFuncs interface {
	HandlerRegistryFuncs
	KeyRegistryFuncs

	HandlerRegistryProvider
	KeyRegistryProvider

	TSAUrl() string
	SetTSAUrl(url string)
}

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.
	// 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
}

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

type SignerRegistry 

type SignerRegistry interface {
	SignerRegistryFuncs

	Copy() SignerRegistry
}

func NewSignerRegistry 

func NewSignerRegistry(parents ...SignerRegistry) SignerRegistry

type SignerRegistryFuncs 

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 

type SignerRegistryProvider interface {
	SignerRegistry() SignerRegistry
}

type SigningContext 

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

type ValueChecker 

type ValueChecker func(value interface{}) bool

type ValueMapper 

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

type ValueMappingRule 

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, sig *Signature, sctx SigningContext) 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-pss
rsa-pss-signingservice
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.