jose

package
v0.0.1 Latest Latest
Warning

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

Go to latest
Published: Aug 7, 2018 License: MIT Imports: 19 Imported by: 0

Documentation

Index

Constants

View Source
const (
	RSA1_5             = KeyAlgorithm("RSA1_5")             // RSA-PKCS1v1.5
	RSA_OAEP           = KeyAlgorithm("RSA-OAEP")           // RSA-OAEP-SHA1
	RSA_OAEP_256       = KeyAlgorithm("RSA-OAEP-256")       // RSA-OAEP-SHA256
	A128KW             = KeyAlgorithm("A128KW")             // AES key wrap (128)
	A192KW             = KeyAlgorithm("A192KW")             // AES key wrap (192)
	A256KW             = KeyAlgorithm("A256KW")             // AES key wrap (256)
	DIRECT             = KeyAlgorithm("dir")                // Direct encryption
	ECDH_ES            = KeyAlgorithm("ECDH-ES")            // ECDH-ES
	ECDH_ES_A128KW     = KeyAlgorithm("ECDH-ES+A128KW")     // ECDH-ES + AES key wrap (128)
	ECDH_ES_A192KW     = KeyAlgorithm("ECDH-ES+A192KW")     // ECDH-ES + AES key wrap (192)
	ECDH_ES_A256KW     = KeyAlgorithm("ECDH-ES+A256KW")     // ECDH-ES + AES key wrap (256)
	A128GCMKW          = KeyAlgorithm("A128GCMKW")          // AES-GCM key wrap (128)
	A192GCMKW          = KeyAlgorithm("A192GCMKW")          // AES-GCM key wrap (192)
	A256GCMKW          = KeyAlgorithm("A256GCMKW")          // AES-GCM key wrap (256)
	PBES2_HS256_A128KW = KeyAlgorithm("PBES2-HS256+A128KW") // PBES2 + HMAC-SHA256 + AES key wrap (128)
	PBES2_HS384_A192KW = KeyAlgorithm("PBES2-HS384+A192KW") // PBES2 + HMAC-SHA384 + AES key wrap (192)
	PBES2_HS512_A256KW = KeyAlgorithm("PBES2-HS512+A256KW") // PBES2 + HMAC-SHA512 + AES key wrap (256)
)

Key management algorithms

View Source
const (
	HS256 = "HS256" // HMAC using SHA-256
	HS384 = "HS384" // HMAC using SHA-384
	HS512 = "HS512" // HMAC using SHA-512
	RS256 = "RS256" // RSASSA-PKCS-v1.5 using SHA-256
	RS384 = "RS384" // RSASSA-PKCS-v1.5 using SHA-384
	RS512 = "RS512" // RSASSA-PKCS-v1.5 using SHA-512
	ES256 = "ES256" // ECDSA using P-256 and SHA-256
	ES384 = "ES384" // ECDSA using P-384 and SHA-384
	ES512 = "ES512" // ECDSA using P-521 and SHA-512
	PS256 = "PS256" // RSASSA-PSS using SHA256 and MGF1-SHA256
	PS384 = "PS384" // RSASSA-PSS using SHA384 and MGF1-SHA384
	PS512 = "PS512" // RSASSA-PSS using SHA512 and MGF1-SHA512
	EdDSA = "EdDSA" // Ed25591
)

Signature algorithms

View Source
const (
	A128CBC_HS256 = ContentEncryption("A128CBC-HS256") // AES-CBC + HMAC-SHA256 (128)
	A192CBC_HS384 = ContentEncryption("A192CBC-HS384") // AES-CBC + HMAC-SHA384 (192)
	A256CBC_HS512 = ContentEncryption("A256CBC-HS512") // AES-CBC + HMAC-SHA512 (256)
	A128GCM       = ContentEncryption("A128GCM")       // AES-GCM (128)
	A192GCM       = ContentEncryption("A192GCM")       // AES-GCM (192)
	A256GCM       = ContentEncryption("A256GCM")       // AES-GCM (256)
)

Content encryption algorithms

View Source
const (
	P256 = "P-256" // P-256 curve (FIPS 186-3)
	P384 = "P-384" // P-384 curve (FIPS 186-3)
	P521 = "P-521" // P-521 curve (FIPS 186-3)
)

Elliptic curves

View Source
const (
	// Key management algorithms
	DefaultECKeyAlgorithm  = ECDH_ES
	DefaultRSAKeyAlgorithm = RSA_OAEP_256
	DefaultOctKeyAlgorithm = A256GCMKW
	// Signature algorithms
	DefaultRSASigAlgorithm  = RS256
	DefaultOctSigsAlgorithm = HS256
	// Content encryption algorithm
	DefaultEncAlgorithm = A256GCM
)

Default key management, signature, and content encryption algorithms to use if none is specified.

View Source
const (
	DefaultRSASize = 2048
	DefaultOctSize = 32
)

Default sizes

View Source
const Ed25519 = "Ed25519"

Ed25519 is the EdDSA signature scheme using SHA-512/256 and Curve25519

View Source
const MaxDecryptTries = 3

MaxDecryptTries is the maximum number of attempts to decrypt a file.

View Source
const SupportsPBKDF2 = true

SupportsPBKDF2 constant to know if the underlaying library supports password based cryptography algorithms.

Variables

View Source
var ErrCryptoFailure = jose.ErrCryptoFailure

ErrCryptoFailure indicates an error in a cryptographic primitive.

View Source
var ErrExpired = jwt.ErrExpired

ErrExpired indicates that token is used after expiry time indicated in exp claim.

View Source
var ErrInvalidAudience = jwt.ErrInvalidAudience

ErrInvalidAudience indicated invalid aud claim.

View Source
var ErrInvalidID = jwt.ErrInvalidID

ErrInvalidID indicates invalid jti claim.

View Source
var ErrInvalidIssuer = jwt.ErrInvalidIssuer

ErrInvalidIssuer indicates invalid iss claim.

View Source
var ErrInvalidSubject = jwt.ErrInvalidSubject

ErrInvalidSubject indicates invalid sub claim.

View Source
var ErrNotValidYet = jwt.ErrNotValidYet

ErrNotValidYet indicates that token is used before time indicated in nbf claim.

Functions

func Decrypt

func Decrypt(prompt string, data []byte, opts ...Option) ([]byte, error)

Decrypt returns the decrypted version of the given data if it's encrypted, it will return the raw data if it's not encrypted or the format is not valid.

func IsAsymmetric

func IsAsymmetric(k *JSONWebKey) bool

Determine whether a JSONWebKey is asymmetric

func IsSymmetric

func IsSymmetric(k *JSONWebKey) bool

Determine whether a JSONWebKey is symmetric

func ParseKeySet

func ParseKeySet(filename string, opts ...Option) (*jose.JSONWebKey, error)

ParseKeySet returns the JWK with the given key after parsing a JWKSet from a given file. func ParseKeySet(filename, alg, kid string, isSubtle bool) (*jose.JSONWebKey, error) {

func ReadJWKSet

func ReadJWKSet(filename string) ([]byte, error)

ReadJWKSet reads a JWK Set from a URL or filename. URLs must start with "https://".

func TrimPrefix

func TrimPrefix(err error) error

TrimPrefix removes the string "square/go-jose" from all errors.

func ValidateJWK

func ValidateJWK(jwk *JSONWebKey) error

ValidateJWK validates the given JWK.

Types

type Audience

type Audience = jwt.Audience

Audience represents the recipients that the token is intended for.

type Builder

type Builder = jwt.Builder

Builder is a utility for making JSON Web Tokens. Calls can be chained, and errors are accumulated until the final call to CompactSerialize/FullSerialize.

func Signed

func Signed(sig Signer) Builder

Signed creates builder for signed tokens.

type Claims

type Claims = jwt.Claims

Claims represents public claim values (as specified in RFC 7519).

type ContentEncryption

type ContentEncryption = jose.ContentEncryption

ContentEncryption represents a content encryption algorithm.

type ContentType

type ContentType = jose.ContentType

ContentType represents type of the contained data.

type Encrypter

type Encrypter = jose.Encrypter

Encrypter represents an encrypter which produces an encrypted JWE object.

func NewEncrypter

func NewEncrypter(enc ContentEncryption, rcpt Recipient, opts *EncrypterOptions) (Encrypter, error)

NewEncrypter creates an appropriate encrypter based on the key type.

type EncrypterOptions

type EncrypterOptions = jose.EncrypterOptions

EncrypterOptions represents options that can be set on new encrypters.

type Expected

type Expected = jwt.Expected

Expected defines values used for protected claims validation. If field has zero value then validation is skipped.

type JSONWebEncryption

type JSONWebEncryption = jose.JSONWebEncryption

JSONWebEncryption represents an encrypted JWE object after parsing.

func ParseEncrypted

func ParseEncrypted(input string) (*JSONWebEncryption, error)

ParseEncrypted parses an encrypted message in compact or full serialization format.

type JSONWebKey

type JSONWebKey = jose.JSONWebKey

JSONWebKey represents a public or private key in JWK format.

func GenerateJWK

func GenerateJWK(kty, crv, alg, use, kid string, size int) (jwk *JSONWebKey, err error)

GenerateJWK generates a JWK given the key type, curve, alg, use, kid and the size of the RSA or oct keys if necessary.

func GenerateJWKFromPEM

func GenerateJWKFromPEM(filename string) (*JSONWebKey, error)

GenerateJWKFromPEM returns an incomplete JSONWebKey using the key from a PEM file.

func ParseKey

func ParseKey(filename string, opts ...Option) (*JSONWebKey, error)

ParseKey returns a JSONWebKey from the given JWK file or a PEM file. For password protected keys, it will ask the user for a password. func ParseKey(filename, use, alg, kid string, subtle bool) (*JSONWebKey, error) {

type JSONWebKeySet

type JSONWebKeySet = jose.JSONWebKeySet

JSONWebKeySet represents a JWK Set object.

type JSONWebSignature

type JSONWebSignature = jose.JSONWebSignature

JSONWebSignature represents a signed JWS object after parsing.

func ParseJWS

func ParseJWS(s string) (*JSONWebSignature, error)

ParseJWS parses a signed message in compact or full serialization format.

type JSONWebToken

type JSONWebToken = jwt.JSONWebToken

JSONWebToken represents a JSON Web Token (as specified in RFC7519).

func ParseSigned

func ParseSigned(s string) (*JSONWebToken, error)

ParseSigned parses token from JWS form.

type KeyAlgorithm

type KeyAlgorithm = jose.KeyAlgorithm

KeyAlgorithm represents a key management algorithm.

type NumericDate

type NumericDate = jwt.NumericDate

NumericDate represents date and time as the number of seconds since the epoch, including leap seconds. Non-integer values can be represented in the serialized format, but we round to the nearest second.

func NewNumericDate

func NewNumericDate(t time.Time) NumericDate

NewNumericDate constructs NumericDate from time.Time value.

type Option

type Option func(ctx *context)

Option is the type used to add attributes to the context.

func WithAlg

func WithAlg(alg string) Option

WithAlg adds the alg claim to the context.

func WithInsecure

func WithInsecure(insecure bool) Option

WithInsecure marks the context as insecure.

func WithKid

func WithKid(kid string) Option

WithKid adds the kid property to the context.

func WithNoDefaults

func WithNoDefaults(val bool) Option

WithNoDefaults avoids that the parser loads defaults values, specially the default algorithms.

func WithPassword

func WithPassword(pass []byte) Option

WithPassword is a method that adds the given password to the context.

func WithSubtle

func WithSubtle(subtle bool) Option

WithSubtle marks the context as subtle.

func WithUse

func WithUse(use string) Option

WithUse adds the use claim to the context.

type Recipient

type Recipient = jose.Recipient

Recipient represents an algorithm/key to encrypt messages to.

type SignatureAlgorithm

type SignatureAlgorithm = jose.SignatureAlgorithm

SignatureAlgorithm represents a signature (or MAC) algorithm.

type Signer

type Signer = jose.Signer

Signer represents a signer which takes a payload and produces a signed JWS object.

func NewSigner

func NewSigner(sig SigningKey, opts *SignerOptions) (Signer, error)

NewSigner creates an appropriate signer based on the key type

type SignerOptions

type SignerOptions = jose.SignerOptions

SignerOptions represents options that can be set when creating signers.

type SigningKey

type SigningKey = jose.SigningKey

SigningKey represents an algorithm/key used to sign a message.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL