wrapping

type AeadType uint32

type BlobInfo struct {

	// Ciphertext is the encrypted bytes
	// @gotags: class:"public"
	Ciphertext []byte `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty" class:"public"`
	// IV is the initialization value used during encryption
	// @gotags: class:"secret"
	Iv []byte `protobuf:"bytes,2,opt,name=iv,proto3" json:"iv,omitempty" class:"secret"`
	// HMAC is the bytes of the HMAC, if any
	// @gotags: class:"public"
	Hmac []byte `protobuf:"bytes,3,opt,name=hmac,proto3" json:"hmac,omitempty" class:"public"`
	// Wrapped can be used by the client to indicate whether Ciphertext actually
	// contains wrapped data or not. This can be useful if you want to reuse the
	// same struct to pass data along before and after wrapping. Deprecated in
	// favor of plaintext.
	//
	// Deprecated: Marked as deprecated in github.com.hashicorp.go.kms.wrapping.v2.types.proto.
	Wrapped bool `protobuf:"varint,4,opt,name=wrapped,proto3" json:"wrapped,omitempty"`
	// Plaintext can be used to allow the same struct to be used to pass data
	// along before and after (un)wrapping.
	// @gotags: class:"secret"
	Plaintext []byte `protobuf:"bytes,7,opt,name=plaintext,proto3" json:"plaintext,omitempty" class:"secret"`
	// KeyInfo contains information about the key that was used to create this value
	KeyInfo *KeyInfo `protobuf:"bytes,5,opt,name=key_info,json=keyInfo,proto3" json:"key_info,omitempty"`
	// ValuePath can be used by the client to store information about where the
	// value came from. Deprecated in favor of client_data.
	// @gotags: class:"public"
	//
	// Deprecated: Marked as deprecated in github.com.hashicorp.go.kms.wrapping.v2.types.proto.
	ValuePath string `protobuf:"bytes,6,opt,name=value_path,json=valuePath,proto3" json:"value_path,omitempty" class:"public"`
	// ClientData can be used by the client to store extra information, for
	// instance, the location/provenance of where an encrypted value came from
	// (useful for associating AAD to the encrypted value).
	ClientData *structpb.Struct `protobuf:"bytes,8,opt,name=client_data,json=clientData,proto3" json:"client_data,omitempty"`
	// contains filtered or unexported fields
}

type EnvelopeInfo struct {

	// Ciphertext is the ciphertext from the envelope
	// @gotags: class:"public"
	Ciphertext []byte `protobuf:"bytes,1,opt,name=ciphertext,proto3" json:"ciphertext,omitempty" class:"public"`
	// Key is the key used in the envelope
	// @gotags: class:"secret"
	Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty" class:"secret"`
	// IV is the initialization value used during encryption in the envelope
	// @gotags: class:"secret"
	Iv []byte `protobuf:"bytes,3,opt,name=iv,proto3" json:"iv,omitempty" class:"secret"`
	// contains filtered or unexported fields
}

type HashType uint32

type HmacComputer interface {
	// HmacKeyID is the ID of the key currently used for HMACing (if any)
	HmacKeyId(context.Context) (string, error)
}

type HmacType int32

type InitFinalizer interface {
	// Init allows performing any necessary setup calls before using a
	// Wrapper.
	Init(ctx context.Context, options ...Option) error

	// Finalize can be called when all usage of a Wrapper is done if any cleanup
	// or finalization is required.
	Finalize(ctx context.Context, options ...Option) error
}

type KeyEncoding int32

type KeyExporter interface {
	// KeyBytes returns the "current" key bytes
	KeyBytes(context.Context) ([]byte, error)
}

type KeyInfo struct {

	// Mechanism is the method used by the wrapper to encrypt and sign the
	// data as defined by the wrapper. (optional)
	Mechanism     uint64 `protobuf:"varint,1,opt,name=mechanism,proto3" json:"mechanism,omitempty"`
	HmacMechanism uint64 `protobuf:"varint,2,opt,name=hmac_mechanism,json=hmacMechanism,proto3" json:"hmac_mechanism,omitempty"`
	// This is an opaque ID used by the wrapper to identify the specific key to
	// use as defined by the wrapper. This could be a version, key label, or
	// something else. (optional)
	// @gotags: class:"public"
	KeyId string `protobuf:"bytes,3,opt,name=key_id,json=keyId,proto3" json:"key_id,omitempty" class:"public"`
	// @gotags: class:"public"
	HmacKeyId string `protobuf:"bytes,4,opt,name=hmac_key_id,json=hmacKeyId,proto3" json:"hmac_key_id,omitempty" class:"public"`
	// These value are used when generating our own data encryption keys
	// and encrypting them using the wrapper (optional)
	// @gotags: class:"secret"
	WrappedKey []byte `protobuf:"bytes,5,opt,name=wrapped_key,json=wrappedKey,proto3" json:"wrapped_key,omitempty" class:"secret"`
	// Mechanism specific flags (optional)
	Flags uint64 `protobuf:"varint,6,opt,name=flags,proto3" json:"flags,omitempty"`
	// The key type (optional)
	KeyType KeyType `` /* 142-byte string literal not displayed */
	// The key purposes (optional)
	KeyPurposes []KeyPurpose `` /* 164-byte string literal not displayed */
	// plaintext key used when generating our own data encryption
	// keys (optional)
	// @gotags: class:"secret"
	Key []byte `protobuf:"bytes,9,opt,name=key,proto3" json:"key,omitempty" class:"secret"`
	// encoding of the key (optional)
	KeyEncoding KeyEncoding `` /* 159-byte string literal not displayed */
	// encoding of the wrapped_key (optional)
	WrappedKeyEncoding KeyEncoding `` /* 182-byte string literal not displayed */
	// contains filtered or unexported fields
}

type KeyPurpose int32

type KeyType int32

type Option func() interface{}

type OptionFunc func(*Options) error

type Options struct {

	// The key ID being specified
	// @gotags: class:"public"
	WithKeyId string `protobuf:"bytes,10,opt,name=with_key_id,json=withKeyId,proto3" json:"with_key_id,omitempty" class:"public"`
	// The AAD bytes, if any
	// @gotags: class:"secret"
	WithAad []byte `protobuf:"bytes,20,opt,name=with_aad,json=withAad,proto3" json:"with_aad,omitempty" class:"secret"`
	// @gotags: class:"secret"
	WithIv []byte `protobuf:"bytes,12,opt,name=with_iv,json=withIv,proto3" json:"with_iv,omitempty" class:"secret"`
	// Wrapper-specific configuration to pass along
	WithConfigMap map[string]string `` /* 191-byte string literal not displayed */
	// The purposes of the key being specified
	WithKeyPurposes []KeyPurpose `` /* 179-byte string literal not displayed */
	// The type of the key being specified
	WithKeyType KeyType `` /* 157-byte string literal not displayed */
	// optional bytes of entropy
	// @gotags: class:"secret"
	WithRandomBytes []byte `protobuf:"bytes,60,opt,name=with_random_bytes,json=withRandomBytes,proto3" json:"with_random_bytes,omitempty" class:"secret"`
	// encoding of the key
	WithKeyEncoding KeyEncoding `` /* 173-byte string literal not displayed */
	// encoding of the wrapped_key
	WithWrappedKeyEncoding KeyEncoding `` /* 196-byte string literal not displayed */
	WithDisallowEnvVars    bool        `protobuf:"varint,90,opt,name=with_disallow_env_vars,json=withDisallowEnvVars,proto3" json:"with_disallow_env_vars,omitempty"`
	// WithoutHmac specifies that an HMAC is not necessary for the mechanism, even if marked as "required"
	WithoutHmac bool `protobuf:"varint,100,opt,name=without_hmac,json=withoutHmac,proto3" json:"without_hmac,omitempty"`
	// contains filtered or unexported fields
}

type SigInfo struct {

	// KeyInfo contains information about the key that was used to create this value
	KeyInfo *KeyInfo `protobuf:"bytes,10,opt,name=key_info,json=keyInfo,proto3" json:"key_info,omitempty"`
	// Signature contains the bytes of the signature
	// @gotags: class:"public"
	Signature []byte `protobuf:"bytes,20,opt,name=signature,proto3" json:"signature,omitempty" class:"public"`
	// HmacType (optional) defines the hmac algorithm used
	HmacType *HmacType `` /* 153-byte string literal not displayed */
	// contains filtered or unexported fields
}

type SigInfoSigner interface {
	// Sign creates a msg signature in the form of a SigInfo
	Sign(ctx context.Context, msg []byte, opt ...Option) (*SigInfo, error)
}

type SigInfoVerifier interface {
	// Verify a msg signature in the form of a SigInfo
	Verify(ctx context.Context, msg []byte, sig *SigInfo, opt ...Option) (bool, error)
}

type TestInitFinalizer struct {
	*TestWrapper
}

type TestInitFinalizerHmacComputer struct {
	*TestInitFinalizer
}

type TestWrapper struct {
	ReturnKeyIdError   error
	ReturnDecryptError error
	ReturnEncryptError error
	// contains filtered or unexported fields
}

type Wrapper interface {
	// Type is the type of Wrapper
	Type(context.Context) (WrapperType, error)

	// KeyId is the ID of the key currently used for encryption
	KeyId(context.Context) (string, error)

	// SetConfig applies the given options to a wrapper and returns
	// configuration information. WithConfigMap will almost certainly be
	// required to be passed in to give wrapper-specific configuration
	// information to the wrapper. WithKeyId is also supported.
	SetConfig(ctx context.Context, options ...Option) (*WrapperConfig, error)

	// Encrypt encrypts the given byte slice and stores the resulting
	// information in the returned blob info. Which options are used depends on
	// the underlying wrapper. Supported options: WithAad.
	Encrypt(ctx context.Context, plaintext []byte, options ...Option) (*BlobInfo, error)
	// Decrypt decrypts the given byte slice and stores the resulting
	// information in the returned byte slice. Which options are used depends on
	// the underlying wrapper. Supported options: WithAad.
	Decrypt(ctx context.Context, ciphertext *BlobInfo, options ...Option) ([]byte, error)
}

type WrapperConfig struct {
	Metadata map[string]string `` /* 158-byte string literal not displayed */
	// contains filtered or unexported fields
}

type WrapperType string