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

jwe

package

Go to main page

Versions in this module

v0

v0.9.2

Apr 13, 2020

v0.9.1

Feb 26, 2020

v0.9.0

May 20, 2019

Changes in this version

+ const TagSize

+ var CbcAeadFetch = AeadFetchFunc(func(key []byte) (cipher.AEAD, error) { ... })

+ var ErrInvalidBlockSize = errors.New("keywrap input must be 8 byte blocks")

+ var ErrInvalidCompactPartsCount = errors.New("compact JWE format must have five parts")

+ var ErrInvalidHeaderValue = errors.New("invalid value for header key")

+ var ErrMissingPrivateKey = errors.New("missing private key")

+ var ErrUnsupportedAlgorithm = errors.New("unsupported algorithm")

+ var GcmAeadFetch = AeadFetchFunc(func(key []byte) (cipher.AEAD, error) { ... })

+ func Decrypt(buf []byte, alg jwa.KeyEncryptionAlgorithm, key interface{}) ([]byte, error)

+ func Encrypt(payload []byte, keyalg jwa.KeyEncryptionAlgorithm, key interface{}, ...) ([]byte, error)

+ func NewErrUnsupportedAlgorithm(alg, purpose string) errUnsupportedAlgorithm

+ type AeadFetchFunc func([]byte) (cipher.AEAD, error)

+ func (f AeadFetchFunc) AeadFetch(key []byte) (cipher.AEAD, error)

+ type AeadFetcher interface

+ AeadFetch func([]byte) (cipher.AEAD, error)

+ type AesContentCipher struct

+ NonceGenerator KeyGenerator

+ func NewAesContentCipher(alg jwa.ContentEncryptionAlgorithm) (*AesContentCipher, error)

+ func (c AesContentCipher) KeySize() int

+ func (c AesContentCipher) TagSize() int

+ type ByteKey []byte

+ func (k ByteKey) Bytes() []byte

+ type ByteSource interface

+ Bytes func() []byte

+ type ByteWithECPrivateKey struct

+ PrivateKey *ecdsa.PrivateKey

+ func (k ByteWithECPrivateKey) HeaderPopulate(h *Header)

+ type CompactSerialize struct

+ func (s CompactSerialize) Serialize(m *Message) ([]byte, error)

+ type ContentCipher interface

+ KeySize func() int

+ type ContentEncrypter interface

+ Algorithm func() jwa.ContentEncryptionAlgorithm

+ Encrypt func([]byte, []byte, []byte) ([]byte, []byte, []byte, error)

+ type DirectDecrypt struct

+ Key []byte

+ func (d DirectDecrypt) Decrypt() ([]byte, error)

+ type EcdhesKeyGenerate struct

+ func NewEcdhesKeyGenerate(alg jwa.KeyEncryptionAlgorithm, pubkey *ecdsa.PublicKey) (*EcdhesKeyGenerate, error)

+ func (g EcdhesKeyGenerate) KeyGenerate() (ByteSource, error)

+ func (g EcdhesKeyGenerate) KeySize() int

+ type EcdhesKeyWrapDecrypt struct

+ func NewEcdhesKeyWrapDecrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *ecdsa.PublicKey, apu, apv []byte, ...) *EcdhesKeyWrapDecrypt

+ func (kw EcdhesKeyWrapDecrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (kw EcdhesKeyWrapDecrypt) KeyDecrypt(enckey []byte) ([]byte, error)

+ type EcdhesKeyWrapEncrypt struct

+ KeyID string

+ func NewEcdhesKeyWrapEncrypt(alg jwa.KeyEncryptionAlgorithm, key *ecdsa.PublicKey) (*EcdhesKeyWrapEncrypt, error)

+ func (kw EcdhesKeyWrapEncrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (kw EcdhesKeyWrapEncrypt) KeyEncrypt(cek []byte) (ByteSource, error)

+ func (kw EcdhesKeyWrapEncrypt) Kid() string

+ type EncodedHeader struct

+ func NewEncodedHeader() *EncodedHeader

+ func (e *EncodedHeader) UnmarshalJSON(buf []byte) error

+ func (e EncodedHeader) Base64Encode() ([]byte, error)

+ func (e EncodedHeader) MarshalJSON() ([]byte, error)

+ type Encrypter interface

+ Encrypt func([]byte) (*Message, error)

+ type EssentialHeader struct

+ AgreementPartyUInfo buffer.Buffer

+ AgreementPartyVInfo buffer.Buffer

+ Algorithm jwa.KeyEncryptionAlgorithm

+ Compression jwa.CompressionAlgorithm

+ ContentEncryption jwa.ContentEncryptionAlgorithm

+ ContentType string

+ Critical []string

+ EphemeralPublicKey *jwk.ECDSAPublicKey

+ Jwk jwk.Key

+ JwkSetURL *url.URL

+ KeyID string

+ Type string

+ X509CertChain []string

+ X509CertThumbprint string

+ X509CertThumbprintS256 string

+ X509Url *url.URL

+ func (h *EssentialHeader) Copy(h2 *EssentialHeader)

+ func (h *EssentialHeader) Merge(h2 *EssentialHeader)

+ type GenericContentCrypt struct

+ func NewAesCrypt(alg jwa.ContentEncryptionAlgorithm) (*GenericContentCrypt, error)

+ func (c GenericContentCrypt) Algorithm() jwa.ContentEncryptionAlgorithm

+ func (c GenericContentCrypt) Decrypt(cek, iv, ciphertext, tag, aad []byte) ([]byte, error)

+ func (c GenericContentCrypt) Encrypt(cek, plaintext, aad []byte) ([]byte, []byte, []byte, error)

+ func (c GenericContentCrypt) KeySize() int

+ type Header struct

+ PrivateParams map[string]interface{}

+ func NewHeader() *Header

+ func (h *Header) Copy(h2 *Header) error

+ func (h *Header) Get(key string) (interface{}, error)

+ func (h *Header) Merge(h2 *Header) (*Header, error)

+ func (h *Header) Set(key string, value interface{}) error

+ func (h *Header) UnmarshalJSON(data []byte) error

+ func (h Header) MarshalJSON() ([]byte, error)

+ type HeaderPopulater interface

+ HeaderPopulate func(*Header)

+ type JSONSerialize struct

+ Pretty bool

+ func (s JSONSerialize) Serialize(m *Message) ([]byte, error)

+ type KeyDecrypter interface

+ Algorithm func() jwa.KeyEncryptionAlgorithm

+ KeyDecrypt func([]byte) ([]byte, error)

+ func BuildKeyDecrypter(alg jwa.KeyEncryptionAlgorithm, h *Header, key interface{}, keysize int) (KeyDecrypter, error)

+ type KeyEncrypter interface

+ Algorithm func() jwa.KeyEncryptionAlgorithm

+ KeyEncrypt func([]byte) (ByteSource, error)

+ Kid func() string

+ type KeyGenerator interface

+ KeyGenerate func() (ByteSource, error)

+ KeySize func() int

+ type KeyWrapEncrypt struct

+ KeyID string

+ func NewKeyWrapEncrypt(alg jwa.KeyEncryptionAlgorithm, sharedkey []byte) (KeyWrapEncrypt, error)

+ func (kw KeyWrapEncrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (kw KeyWrapEncrypt) KeyDecrypt(enckey []byte) ([]byte, error)

+ func (kw KeyWrapEncrypt) KeyEncrypt(cek []byte) (ByteSource, error)

+ func (kw KeyWrapEncrypt) Kid() string

+ type Message struct

+ AuthenticatedData buffer.Buffer

+ CipherText buffer.Buffer

+ InitializationVector buffer.Buffer

+ ProtectedHeader *EncodedHeader

+ Recipients []Recipient

+ Tag buffer.Buffer

+ UnprotectedHeader *Header

+ func NewMessage() *Message

+ func Parse(buf []byte) (*Message, error)

+ func ParseString(s string) (*Message, error)

+ func (m *Message) Decrypt(alg jwa.KeyEncryptionAlgorithm, key interface{}) ([]byte, error)

+ type MultiEncrypt struct

+ ContentEncrypter ContentEncrypter

+ KeyEncrypters []KeyEncrypter

+ KeyGenerator KeyGenerator

+ func NewMultiEncrypt(cc ContentEncrypter, kg KeyGenerator, ke ...KeyEncrypter) *MultiEncrypt

+ func (e MultiEncrypt) Encrypt(plaintext []byte) (*Message, error)

+ type RSAOAEPKeyDecrypt struct

+ func NewRSAOAEPKeyDecrypt(alg jwa.KeyEncryptionAlgorithm, privkey *rsa.PrivateKey) (*RSAOAEPKeyDecrypt, error)

+ func (d RSAOAEPKeyDecrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (d RSAOAEPKeyDecrypt) KeyDecrypt(enckey []byte) ([]byte, error)

+ type RSAOAEPKeyEncrypt struct

+ KeyID string

+ func NewRSAOAEPKeyEncrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RSAOAEPKeyEncrypt, error)

+ func (e RSAOAEPKeyEncrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (e RSAOAEPKeyEncrypt) KeyEncrypt(cek []byte) (ByteSource, error)

+ func (e RSAOAEPKeyEncrypt) Kid() string

+ type RSAPKCS15KeyDecrypt struct

+ func NewRSAPKCS15KeyDecrypt(alg jwa.KeyEncryptionAlgorithm, privkey *rsa.PrivateKey, keysize int) *RSAPKCS15KeyDecrypt

+ func (d RSAPKCS15KeyDecrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (d RSAPKCS15KeyDecrypt) KeyDecrypt(enckey []byte) ([]byte, error)

+ type RSAPKCSKeyEncrypt struct

+ KeyID string

+ func NewRSAPKCSKeyEncrypt(alg jwa.KeyEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RSAPKCSKeyEncrypt, error)

+ func (e RSAPKCSKeyEncrypt) Algorithm() jwa.KeyEncryptionAlgorithm

+ func (e RSAPKCSKeyEncrypt) KeyEncrypt(cek []byte) (ByteSource, error)

+ func (e RSAPKCSKeyEncrypt) Kid() string

+ type RandomKeyGenerate struct

+ func NewRandomKeyGenerate(n int) RandomKeyGenerate

+ func (g RandomKeyGenerate) KeyGenerate() (ByteSource, error)

+ func (g RandomKeyGenerate) KeySize() int

+ type Recipient struct

+ EncryptedKey buffer.Buffer

+ Header *Header

+ func NewRecipient() *Recipient

+ type RsaContentCipher struct

+ func NewRsaContentCipher(alg jwa.ContentEncryptionAlgorithm, pubkey *rsa.PublicKey) (*RsaContentCipher, error)

+ type Serializer interface

+ Serialize func(*Message) ([]byte, error)

+ type StaticKeyGenerate []byte

+ func (g StaticKeyGenerate) KeyGenerate() (ByteSource, error)

+ func (g StaticKeyGenerate) KeySize() int