sdk

package
v6.0.3 Latest Latest
Warning

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

 Go to latest Published: Feb 17, 2020 License: BSD-3-Clause Imports: 15 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	SelfSigner   = "self"
	VirgilSigner = "virgil"
)
View Source 
const (
	CardVersion = "5.0"
)

Variables

View Source 
var (
	ErrInvalidCardID         = errors.New("invalid card id")
	ErrIdentityIsMandatory   = errors.New("identity is mandatory")
	ErrPrivateKeyIsMandatory = errors.New("private key is mandatory")
	ErrCryptoIsMandatory     = errors.New("crypto is mandatory")
	ErrCardIsMandatory       = errors.New("card is mandatory")
	ErrCardPublicKeyUnset    = errors.New("card public key is not set")

	CSRIdentityEmptyErr        = errors.New("Identity field in CSR is mandatory")
	CSRSignParamIncorrectErr   = errors.New("CSR signature params incorrect")
	CSRPublicKeyEmptyErr       = errors.New("Public key field in CSR is mandatory")
	CSRSelfSignAlreadyExistErr = errors.New("The CSR already has a self signature")
	CSRAppSignAlreadyExistErr  = errors.New("The CSR already has an application signature")

	ErrRawSignedModelIsMandatory = errors.New("raw signerd model is mandatory")
	ErrDuplicateSigner           = errors.New("duplicate signer")

	ErrValidationSignature = errors.New("signature validation error")
	ErrSignerWasNotFound   = errors.New("signer was not found")
)

Functions

func GenerateCardID 

func GenerateCardID(data []byte) string

func ParseSnapshot 

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

func TakeSnapshot 

func TakeSnapshot(obj interface{}) ([]byte, error)

Types

type Card 

type Card struct {
	Id             string
	Identity       string
	PublicKey      crypto.PublicKey
	Version        string
	CreatedAt      time.Time
	PreviousCardId string
	PreviousCard   *Card
	IsOutdated     bool

	Signatures      []*CardSignature
	ContentSnapshot []byte
}

func LinkCards 

func LinkCards(cards ...*Card) []*Card

func ParseRawCard 

func ParseRawCard(crypto Crypto, model *RawSignedModel, isOutdated bool) (*Card, error)

func ParseRawCards 

func ParseRawCards(crypto Crypto, models ...*RawSignedModel) ([]*Card, error)

type CardClient 

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

func NewCardsClient 

func NewCardsClient(options ...CardClientOption) *CardClient

func (*CardClient) GetCard 

func (c *CardClient) GetCard(cardID string, token string) (*RawSignedModel, bool, error)

func (*CardClient) PublishCard 

func (c *CardClient) PublishCard(rawCard *RawSignedModel, token string) (*RawSignedModel, error)

func (*CardClient) RevokeCard 

func (c *CardClient) RevokeCard(cardID string, token string) error

func (*CardClient) SearchCards 

func (c *CardClient) SearchCards(identity string, token string) ([]*RawSignedModel, error)

type CardClientOption 

type CardClientOption func(c *cardClientOption)

func SetCardClientHTTPClient 

func SetCardClientHTTPClient(httpClient *http.Client) CardClientOption

func SetCardClientURL 

func SetCardClientURL(serviceURL string) CardClientOption

type CardCrypto 

type CardCrypto struct {
	Crypto Crypto
}

func (*CardCrypto) ExportPublicKey 

func (c *CardCrypto) ExportPublicKey(key crypto.PublicKey) ([]byte, error)

func (*CardCrypto) GenerateSHA512 

func (c *CardCrypto) GenerateSHA512(data []byte) ([]byte, error)

func (*CardCrypto) GenerateSignature 

func (c *CardCrypto) GenerateSignature(data []byte, key crypto.PrivateKey) ([]byte, error)

func (*CardCrypto) ImportPublicKey 

func (c *CardCrypto) ImportPublicKey(data []byte) (crypto.PublicKey, error)

func (*CardCrypto) VerifySignature 

func (c *CardCrypto) VerifySignature(data []byte, signature []byte, key crypto.PublicKey) error

type CardManager 

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

func NewCardManager 

func NewCardManager(accessTokenProvider session.AccessTokenProvider, options ...CardManagerOption) *CardManager

func (*CardManager) ExportCardAsJson 

func (c *CardManager) ExportCardAsJson(card *Card) (string, error)

func (*CardManager) ExportCardAsRawCard 

func (c *CardManager) ExportCardAsRawCard(card *Card) (*RawSignedModel, error)

func (*CardManager) ExportCardAsString 

func (c *CardManager) ExportCardAsString(card *Card) (string, error)

func (*CardManager) GenerateRawCard 

func (c *CardManager) GenerateRawCard(cardParams *CardParams) (*RawSignedModel, error)

func (*CardManager) GetCard 

func (c *CardManager) GetCard(cardID string) (*Card, error)

func (*CardManager) ImportCard 

func (c *CardManager) ImportCard(model *RawSignedModel) (*Card, error)

func (*CardManager) ImportCardFromJson 

func (c *CardManager) ImportCardFromJson(json string) (*Card, error)

func (*CardManager) ImportCardFromString 

func (c *CardManager) ImportCardFromString(str string) (*Card, error)

func (*CardManager) PublishCard 

func (c *CardManager) PublishCard(cardParams *CardParams) (*Card, error)

func (*CardManager) PublishRawCard 

func (c *CardManager) PublishRawCard(rawSignedModel *RawSignedModel) (card *Card, err error)

func (*CardManager) RevokeCard 

func (c *CardManager) RevokeCard(cardID string) error

func (*CardManager) SearchCards 

func (c *CardManager) SearchCards(identity string) (Cards, error)

func (*CardManager) Validate added in v6.0.1 

func (c *CardManager) Validate() error

type CardManagerOption 

type CardManagerOption func(c *CardManager)

func CardManagerSetCardClient 

func CardManagerSetCardClient(cc *CardClient) CardManagerOption

func CardManagerSetCardVerifier 

func CardManagerSetCardVerifier(cv CardVerifier) CardManagerOption

func CardManagerSetCrypto 

func CardManagerSetCrypto(cc Crypto) CardManagerOption

func CardManagerSetModelSigner 

func CardManagerSetModelSigner(ms *ModelSigner) CardManagerOption

func CardManagerSetSignCallback 

func CardManagerSetSignCallback(callback func(model *RawSignedModel) (signedCard *RawSignedModel, err error)) CardManagerOption

type CardParams 

type CardParams struct {
	Identity       string
	PrivateKey     crypto.PrivateKey
	PreviousCardId string
	ExtraFields    map[string]string
}

func (*CardParams) Validate 

func (c *CardParams) Validate() error

type CardSignature 

type CardSignature struct {
	Signer      string
	Signature   []byte
	ExtraFields map[string]string
	Snapshot    []byte
}

type CardVerifier 

type CardVerifier interface {
	VerifyCard(card *Card) error
}

type Cards 

type Cards []*Card

func (Cards) ExtractPublicKeys 

func (c Cards) ExtractPublicKeys() []crypto.PublicKey

type Crypto 

type Crypto interface {
	Sign(data []byte, privateKey crypto.PrivateKey) ([]byte, error)
	VerifySignature(data []byte, signature []byte, publicKey crypto.PublicKey) error
	ExportPublicKey(publicKey crypto.PublicKey) ([]byte, error)
	ImportPublicKey(publicKeySrc []byte) (crypto.PublicKey, error)
	Hash(data []byte, t crypto.HashType) ([]byte, error)
}
var (
	DefaultCrypto Crypto = &crypto.Crypto{}
)

type ModelSigner 

type ModelSigner struct {
	Crypto Crypto
}

func (*ModelSigner) CheckSignatureExists 

func (m *ModelSigner) CheckSignatureExists(model *RawSignedModel, signer string) error

func (*ModelSigner) SelfSign 

func (m *ModelSigner) SelfSign(model *RawSignedModel, privateKey crypto.PrivateKey, extraFields map[string]string) (err error)

func (*ModelSigner) SelfSignRaw 

func (m *ModelSigner) SelfSignRaw(model *RawSignedModel, privateKey crypto.PrivateKey, extraFieldsSnapshot []byte) (err error)

func (*ModelSigner) Sign 

func (m *ModelSigner) Sign(model *RawSignedModel, signer string, privateKey crypto.PrivateKey, extraFields map[string]string) (err error)

func (*ModelSigner) SignRaw 

func (m *ModelSigner) SignRaw(model *RawSignedModel, signer string, privateKey crypto.PrivateKey, extraFieldsSnapshot []byte) (err error)

type RawCardContent 

type RawCardContent struct {
	Identity       string `json:"identity"`
	PublicKey      []byte `json:"public_key"`
	Version        string `json:"version"`
	CreatedAt      int64  `json:"created_at"`
	PreviousCardId string `json:"previous_card_id,omitempty"`
}

type RawCardSignature 

type RawCardSignature struct {
	Signer    string `json:"signer,omitempty"`
	Signature []byte `json:"signature,omitempty"`
	Snapshot  []byte `json:"snapshot,omitempty"`
}

type RawSignedModel 

type RawSignedModel struct {
	ContentSnapshot []byte              `json:"content_snapshot"`
	Signatures      []*RawCardSignature `json:"signatures,omitempty"`
}

func GenerateRawCard 

func GenerateRawCard(crypto Crypto, cardParams *CardParams, createdAt time.Time) (*RawSignedModel, error)

func GenerateRawSignedModelFromJson 

func GenerateRawSignedModelFromJson(json string) (*RawSignedModel, error)

func GenerateRawSignedModelFromString 

func GenerateRawSignedModelFromString(str string) (*RawSignedModel, error)

func ParseCard 

func ParseCard(crypto Crypto, card *Card) (*RawSignedModel, error)

func (*RawSignedModel) ExportAsBase64EncodedString 

func (r *RawSignedModel) ExportAsBase64EncodedString() (string, error)

func (*RawSignedModel) ExportAsJson 

func (r *RawSignedModel) ExportAsJson() (string, error)

type VerifierCredentials 

type VerifierCredentials struct {
	Signer    string
	PublicKey crypto.PublicKey
}

type VirgilCardVerifier 

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

func NewVirgilCardVerifier 

func NewVirgilCardVerifier(options ...VirgilCardVerifierOption) *VirgilCardVerifier

func (*VirgilCardVerifier) GetPublicKeyFromBase64 

func (v *VirgilCardVerifier) GetPublicKeyFromBase64(str string) (crypto.PublicKey, error)

func (*VirgilCardVerifier) ValidateSignerSignature 

func (v *VirgilCardVerifier) ValidateSignerSignature(card *Card, signer string, publicKey crypto.PublicKey) error

func (*VirgilCardVerifier) VerifyCard 

func (v *VirgilCardVerifier) VerifyCard(card *Card) error

type VirgilCardVerifierOption 

type VirgilCardVerifierOption func(v *VirgilCardVerifier)

func VirgilCardVerifierAddWhitelist 

func VirgilCardVerifierAddWhitelist(wl Whitelist) VirgilCardVerifierOption

func VirgilCardVerifierDisableSelfSignature 

func VirgilCardVerifierDisableSelfSignature() VirgilCardVerifierOption

func VirgilCardVerifierDisableVirgilSignature 

func VirgilCardVerifierDisableVirgilSignature() VirgilCardVerifierOption

func VirgilCardVerifierSetCardsServicePublicKey 

func VirgilCardVerifierSetCardsServicePublicKey(ks string) VirgilCardVerifierOption

func VirgilCardVerifierSetCrypto 

func VirgilCardVerifierSetCrypto(c Crypto) VirgilCardVerifierOption

type Whitelist 

type Whitelist struct {
	VerifierCredentials []*VerifierCredentials
}

func NewWhitelist 

func NewWhitelist(credentials ...*VerifierCredentials) Whitelist

Source Files

View all Source files

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.