Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

secrets

package

Go to main page

Versions in this module

v0

v0.2500.0

Feb 7, 2025

v0.2403.2

Feb 3, 2025

v0.2403.1

Nov 29, 2024

v0.2403.0

Oct 15, 2024

v0.2402.0

Aug 20, 2024

v0.2401.0

Jun 28, 2024

v0.2400.0

May 13, 2024

Changes in this version

+ const ChecksumSize

+ const GasOpPublishEphemeralSecret

+ const GasOpPublishMasterSecret

+ const GasOpUpdatePolicy

+ const KeyPairIDSize

+ var DefaultGasCosts = transaction.Costs

+ var EncryptedEphemeralSecretSignatureContext = signature.NewContext("oasis-core/keymanager: encrypted ephemeral secret")

+ var EncryptedMasterSecretSignatureContext = signature.NewContext("oasis-core/keymanager: encrypted master secret")

+ var ErrInvalidArgument = errors.New(moduleName, 1, "keymanager: invalid argument")

+ var ErrNoSuchEphemeralSecret = errors.New(moduleName, 4, "keymanager: no such ephemeral secret")

+ var ErrNoSuchMasterSecret = errors.New(moduleName, 3, "keymanager: no such master secret")

+ var ErrNoSuchStatus = errors.New(moduleName, 2, "keymanager: no such status")

+ var MethodPublishEphemeralSecret = transaction.NewMethodName(moduleName, "PublishEphemeralSecret", SignedEncryptedEphemeralSecret{})

+ var MethodPublishMasterSecret = transaction.NewMethodName(moduleName, "PublishMasterSecret", SignedEncryptedMasterSecret{})

+ var MethodUpdatePolicy = transaction.NewMethodName(moduleName, "UpdatePolicy", SignedPolicySGX{})

+ var Methods = []transaction.MethodName

+ var PolicySGXSignatureContext = signature.NewContext("oasis-core/keymanager: policy")

+ var RPCMethodGenerateEphemeralSecret = "generate_ephemeral_secret"

+ var RPCMethodGenerateMasterSecret = "generate_master_secret"

+ var RPCMethodGetOrCreateEphemeralKeys = "get_or_create_ephemeral_keys"

+ var RPCMethodGetOrCreateKeys = "get_or_create_keys"

+ var RPCMethodGetPublicEphemeralKey = "get_public_ephemeral_key"

+ var RPCMethodGetPublicKey = "get_public_key"

+ var RPCMethodInit = "init"

+ var RPCMethodLoadEphemeralSecret = "load_ephemeral_secret"

+ var RPCMethodLoadMasterSecret = "load_master_secret"

+ var RPCMethodReplicateEphemeralSecret = "replicate_ephemeral_secret"

+ var RPCMethodReplicateMasterSecret = "replicate_master_secret"

+ func NewPublishEphemeralSecretTx(nonce uint64, fee *transaction.Fee, sigSec *SignedEncryptedEphemeralSecret) *transaction.Transaction

+ func NewPublishMasterSecretTx(nonce uint64, fee *transaction.Fee, sigSec *SignedEncryptedMasterSecret) *transaction.Transaction

+ func NewUpdatePolicyTx(nonce uint64, fee *transaction.Fee, sigPol *SignedPolicySGX) *transaction.Transaction

+ func RegisterService(server *grpc.Server, service Backend)

+ func SanityCheckSignedPolicySGX(currentSigPol, newSigPol *SignedPolicySGX) error

+ func SanityCheckStatuses(statuses []*Status) error

+ type Backend interface

+ GetEphemeralSecret func(context.Context, *registry.NamespaceQuery) (*SignedEncryptedEphemeralSecret, error)

+ GetMasterSecret func(context.Context, *registry.NamespaceQuery) (*SignedEncryptedMasterSecret, error)

+ GetStatus func(context.Context, *registry.NamespaceQuery) (*Status, error)

+ GetStatuses func(context.Context, int64) ([]*Status, error)

+ StateToGenesis func(context.Context, int64) (*Genesis, error)

+ WatchEphemeralSecrets func() (<-chan *SignedEncryptedEphemeralSecret, *pubsub.Subscription)

+ WatchMasterSecrets func() (<-chan *SignedEncryptedMasterSecret, *pubsub.Subscription)

+ WatchStatuses func() (<-chan *Status, *pubsub.Subscription)

+ type Client struct

+ func NewClient(c *grpc.ClientConn) *Client

+ func (c *Client) GetEphemeralSecret(ctx context.Context, query *registry.NamespaceQuery) (*SignedEncryptedEphemeralSecret, error)

+ func (c *Client) GetMasterSecret(ctx context.Context, query *registry.NamespaceQuery) (*SignedEncryptedMasterSecret, error)

+ func (c *Client) GetStatus(ctx context.Context, query *registry.NamespaceQuery) (*Status, error)

+ func (c *Client) GetStatuses(ctx context.Context, height int64) ([]*Status, error)

+ func (c *Client) WatchEphemeralSecrets(ctx context.Context) (<-chan *SignedEncryptedEphemeralSecret, pubsub.ClosableSubscription, error)

+ func (c *Client) WatchMasterSecrets(ctx context.Context) (<-chan *SignedEncryptedMasterSecret, pubsub.ClosableSubscription, error)

+ func (c *Client) WatchStatuses(ctx context.Context) (<-chan *Status, pubsub.ClosableSubscription, error)

+ type ConsensusParameterChanges struct

+ GasCosts transaction.Costs

+ func (c *ConsensusParameterChanges) Apply(params *ConsensusParameters) error

+ func (c *ConsensusParameterChanges) SanityCheck() error

+ type ConsensusParameters struct

+ GasCosts transaction.Costs

+ func (p *ConsensusParameters) SanityCheck() error

+ type EnclavePolicySGX struct

+ MayQuery map[common.Namespace][]sgx.EnclaveIdentity

+ MayReplicate []sgx.EnclaveIdentity

+ type EncryptedEphemeralSecret struct

+ Epoch beacon.EpochTime

+ ID common.Namespace

+ Secret EncryptedSecret

+ func (s *EncryptedEphemeralSecret) SanityCheck(epoch beacon.EpochTime, reks map[x25519.PublicKey]struct{}) error

+ type EncryptedMasterSecret struct

+ Epoch beacon.EpochTime

+ Generation uint64

+ ID common.Namespace

+ Secret EncryptedSecret

+ func (s *EncryptedMasterSecret) SanityCheck(generation uint64, epoch beacon.EpochTime, reks map[x25519.PublicKey]struct{}) error

+ type EncryptedSecret struct

+ Checksum []byte

+ Ciphertexts map[x25519.PublicKey][]byte

+ PubKey x25519.PublicKey

+ func (s *EncryptedSecret) SanityCheck(reks map[x25519.PublicKey]struct{}) error

+ type EphemeralKeyRequest struct

+ Epoch beacon.EpochTime

+ Height *uint64

+ ID common.Namespace

+ KeyPairID KeyPairID

+ type EphemeralSecretPublishedEvent struct

+ Secret *SignedEncryptedEphemeralSecret

+ func (ev *EphemeralSecretPublishedEvent) EventKind() string

+ type GenerateEphemeralSecretRequest struct

+ Epoch beacon.EpochTime

+ type GenerateEphemeralSecretResponse struct

+ SignedSecret SignedEncryptedEphemeralSecret

+ type GenerateMasterSecretRequest struct

+ Epoch beacon.EpochTime

+ Generation uint64

+ type GenerateMasterSecretResponse struct

+ SignedSecret SignedEncryptedMasterSecret

+ type Genesis struct

+ Parameters ConsensusParameters

+ Statuses []*Status

+ func (g *Genesis) SanityCheck() error

+ type InitRequest struct

+ Status Status

+ type InitResponse struct

+ Checksum []byte

+ IsSecure bool

+ NextChecksum []byte

+ NextRSK *signature.PublicKey

+ PolicyChecksum []byte

+ RSK *signature.PublicKey

+ type KeyPairID [KeyPairIDSize]byte

+ type LoadEphemeralSecretRequest struct

+ SignedSecret SignedEncryptedEphemeralSecret

+ type LoadMasterSecretRequest struct

+ SignedSecret SignedEncryptedMasterSecret

+ type LongTermKeyRequest struct

+ Generation uint64

+ Height *uint64

+ ID common.Namespace

+ KeyPairID KeyPairID

+ type MasterSecretPublishedEvent struct

+ Secret *SignedEncryptedMasterSecret

+ func (ev *MasterSecretPublishedEvent) EventKind() string

+ type PolicySGX struct

+ Enclaves map[sgx.EnclaveIdentity]*EnclavePolicySGX

+ ID common.Namespace

+ MasterSecretRotationInterval beacon.EpochTime

+ MaxEphemeralSecretAge beacon.EpochTime

+ Serial uint32

+ type SignedEncryptedEphemeralSecret struct

+ Secret EncryptedEphemeralSecret

+ Signature signature.RawSignature

+ func (s *SignedEncryptedEphemeralSecret) Verify(epoch beacon.EpochTime, reks map[x25519.PublicKey]struct{}, ...) error

+ type SignedEncryptedMasterSecret struct

+ Secret EncryptedMasterSecret

+ Signature signature.RawSignature

+ func (s *SignedEncryptedMasterSecret) Verify(generation uint64, epoch beacon.EpochTime, reks map[x25519.PublicKey]struct{}, ...) error

+ type SignedInitResponse struct

+ InitResponse InitResponse

+ Signature []byte

+ func SignInitResponse(signer signature.Signer, response *InitResponse) (*SignedInitResponse, error)

+ func (r *SignedInitResponse) Verify(pk signature.PublicKey) error

+ type SignedPolicySGX struct

+ Policy PolicySGX

+ Signatures []signature.Signature

+ type SignedPublicKey struct

+ Checksum []byte

+ Expiration *beacon.EpochTime

+ Key x25519.PublicKey

+ Signature signature.RawSignature

+ type Status struct

+ Checksum []byte

+ Generation uint64

+ ID common.Namespace

+ IsInitialized bool

+ IsSecure bool

+ Nodes []signature.PublicKey

+ Policy *SignedPolicySGX

+ RSK *signature.PublicKey

+ RotationEpoch beacon.EpochTime

+ func (s *Status) NextGeneration() uint64

+ func (s *Status) VerifyRotationEpoch(epoch beacon.EpochTime) error

+ type StatusUpdateEvent struct

+ Statuses []*Status

+ func (ev *StatusUpdateEvent) EventKind() string