package nkeys

Import Path
	github.com/nats-io/nkeys (on go.dev)

Dependency Relation
	imports 10 packages, and imported by one package

Involved Source Files

	    crc16.go
	    creds_utils.go
	    errors.go
	    keypair.go
	  d nkeys.go
		Package nkeys is an Ed25519 based public-key signature system that simplifies keys and seeds
		and performs signing and verification.
		It also supports encryption via x25519 keys and is compatible with https://pkg.go.dev/golang.org/x/crypto/nacl/box.

	    public.go
	    strkey.go
	    xkeys.go
Package-Level Type Names (total 2)

	/* sort by: alphabet | popularity */
	 type KeyPair (interface)
		KeyPair provides the central interface to nkeys.

		Methods (total 9)
			( KeyPair) Open(input []byte, sender string) ([]byte, error)
				Open is only supported on CurveKey

			( KeyPair) PrivateKey() ([]byte, error)
			( KeyPair) PublicKey() (string, error)
			( KeyPair) Seal(input []byte, recipient string) ([]byte, error)
				Seal is only supported on CurveKeyPair

			( KeyPair) SealWithRand(input []byte, recipient string, rr io.Reader) ([]byte, error)
				SealWithRand is only supported on CurveKeyPair

			( KeyPair) Seed() ([]byte, error)
			( KeyPair) Sign(input []byte) ([]byte, error)
				Sign is only supported on Non CurveKeyPairs

			( KeyPair) Verify(input []byte, sig []byte) error
				Verify is only supported on Non CurveKeyPairs

			( KeyPair) Wipe()
		As Outputs Of (at least 15)
			func CreateAccount() (KeyPair, error)
			func CreateCluster() (KeyPair, error)
			func CreateCurveKeys() (KeyPair, error)
			func CreateCurveKeysWithRand(rr io.Reader) (KeyPair, error)
			func CreateOperator() (KeyPair, error)
			func CreatePair(prefix PrefixByte) (KeyPair, error)
			func CreatePairWithRand(prefix PrefixByte, rr io.Reader) (KeyPair, error)
			func CreateServer() (KeyPair, error)
			func CreateUser() (KeyPair, error)
			func FromCurveSeed(seed []byte) (KeyPair, error)
			func FromPublicKey(public string) (KeyPair, error)
			func FromRawSeed(prefix PrefixByte, rawSeed []byte) (KeyPair, error)
			func FromSeed(seed []byte) (KeyPair, error)
			func ParseDecoratedNKey(contents []byte) (KeyPair, error)
			func ParseDecoratedUserNKey(contents []byte) (KeyPair, error)
		As Inputs Of (at least one exported)
			func CompatibleKeyPair(kp KeyPair, expected ...PrefixByte) error

	 type PrefixByte byte (basic type)
		PrefixByte is a lead byte representing the type.

		Methods (only one)
			( PrefixByte) String() string
		Implements (at least 2)
			 PrefixByte : expvar.Var
			 PrefixByte : fmt.Stringer
		As Outputs Of (at least 2)
			func DecodeSeed(src []byte) (PrefixByte, []byte, error)
			func Prefix(src string) PrefixByte
		As Inputs Of (at least 7)
			func CompatibleKeyPair(kp KeyPair, expected ...PrefixByte) error
			func CreatePair(prefix PrefixByte) (KeyPair, error)
			func CreatePairWithRand(prefix PrefixByte, rr io.Reader) (KeyPair, error)
			func Decode(expectedPrefix PrefixByte, src []byte) ([]byte, error)
			func Encode(prefix PrefixByte, src []byte) ([]byte, error)
			func EncodeSeed(public PrefixByte, src []byte) ([]byte, error)
			func FromRawSeed(prefix PrefixByte, rawSeed []byte) (KeyPair, error)
		As Types Of (total 9)
			const PrefixByteAccount
			const PrefixByteCluster
			const PrefixByteCurve
			const PrefixByteOperator
			const PrefixBytePrivate
			const PrefixByteSeed
			const PrefixByteServer
			const PrefixByteUnknown
			const PrefixByteUser


Package-Level Functions (total 30)

	 func CompatibleKeyPair(kp KeyPair, expected ...PrefixByte) error
		CompatibleKeyPair returns an error if the KeyPair doesn't match expected PrefixByte(s)

	 func CreateAccount() (KeyPair, error)
		CreateAccount will create an Account typed KeyPair.

	 func CreateCluster() (KeyPair, error)
		CreateCluster will create a Cluster typed KeyPair.

	 func CreateCurveKeys() (KeyPair, error)
		CreateCurveKeys will create a Curve typed KeyPair.

	 func CreateCurveKeysWithRand(rr io.Reader) (KeyPair, error)
		CreateCurveKeysWithRand will create a Curve typed KeyPair
		with specified rand source.

	 func CreateOperator() (KeyPair, error)
		CreateOperator will create an Operator typed KeyPair.

	 func CreatePair(prefix PrefixByte) (KeyPair, error)
		CreatePair will create a KeyPair based on the rand entropy and a type/prefix byte.

	 func CreatePairWithRand(prefix PrefixByte, rr io.Reader) (KeyPair, error)
		CreatePair will create a KeyPair based on the rand reader and a type/prefix byte. rand can be nil.

	 func CreateServer() (KeyPair, error)
		CreateServer will create a Server typed KeyPair.

	 func CreateUser() (KeyPair, error)
		CreateUser will create a User typed KeyPair.

	 func Decode(expectedPrefix PrefixByte, src []byte) ([]byte, error)
		Decode will decode the base32 string and check crc16 and enforce the prefix is what is expected.

	 func DecodeSeed(src []byte) (PrefixByte, []byte, error)
		DecodeSeed will decode the base32 string and check crc16 and enforce the prefix is a seed
		and the subsequent type is a valid type.

	 func Encode(prefix PrefixByte, src []byte) ([]byte, error)
		Encode will encode a raw key or seed with the prefix and crc16 and then base32 encoded.

	 func EncodeSeed(public PrefixByte, src []byte) ([]byte, error)
		EncodeSeed will encode a raw key with the prefix and then seed prefix and crc16 and then base32 encoded.
		`src` must be 32 bytes long (ed25519.SeedSize).

	 func FromCurveSeed(seed []byte) (KeyPair, error)
		Will create a curve key pair from seed.

	 func FromPublicKey(public string) (KeyPair, error)
		FromPublicKey will create a KeyPair capable of verifying signatures.

	 func FromRawSeed(prefix PrefixByte, rawSeed []byte) (KeyPair, error)
		FromRawSeed will create a KeyPair from the raw 32 byte seed for a given type.

	 func FromSeed(seed []byte) (KeyPair, error)
		FromSeed will create a KeyPair capable of signing and verifying signatures.

	 func IsValidEncoding(src []byte) bool
		IsValidEncoding will tell you if the encoding is a valid key.

	 func IsValidPublicAccountKey(src string) bool
		IsValidPublicAccountKey will decode and verify the string is a valid encoded Public Account Key.

	 func IsValidPublicClusterKey(src string) bool
		IsValidPublicClusterKey will decode and verify the string is a valid encoded Public Cluster Key.

	 func IsValidPublicCurveKey(src string) bool
		IsValidPublicCurveKey will decode and verify the string is a valid encoded Public Curve Key.

	 func IsValidPublicKey(src string) bool
		IsValidPublicKey will decode and verify that the string is a valid encoded public key.

	 func IsValidPublicOperatorKey(src string) bool
		IsValidPublicOperatorKey will decode and verify the string is a valid encoded Public Operator Key.

	 func IsValidPublicServerKey(src string) bool
		IsValidPublicServerKey will decode and verify the string is a valid encoded Public Server Key.

	 func IsValidPublicUserKey(src string) bool
		IsValidPublicUserKey will decode and verify the string is a valid encoded Public User Key.

	 func ParseDecoratedJWT(contents []byte) (string, error)
		ParseDecoratedJWT takes a creds file and returns the JWT portion.

	 func ParseDecoratedNKey(contents []byte) (KeyPair, error)
		ParseDecoratedNKey takes a creds file, finds the NKey portion and creates a
		key pair from it.

	 func ParseDecoratedUserNKey(contents []byte) (KeyPair, error)
		ParseDecoratedUserNKey takes a creds file, finds the NKey portion and creates a
		key pair from it. Similar to ParseDecoratedNKey but fails for non-user keys.

	 func Prefix(src string) PrefixByte
		Prefix returns PrefixBytes of its input


Package-Level Constants (total 37)

	const ErrCannotOpen nkeysError = "nkeys: cannot open no private curve key available"
		Errors

	const ErrCannotSeal nkeysError = "nkeys: cannot seal no private curve key available"
		Errors

	const ErrCannotSign nkeysError = "nkeys: can not sign, no private key available"
		Errors

	const ErrCouldNotDecrypt nkeysError = "nkeys: could not decrypt input"
		Errors

	const ErrIncompatibleKey nkeysError = "nkeys: incompatible key"
		Errors

	const ErrInvalidChecksum nkeysError = "nkeys: invalid checksum"
		Errors

	const ErrInvalidCurveKey nkeysError = "nkeys: not a valid curve key"
		Errors

	const ErrInvalidCurveKeyOperation nkeysError = "nkeys: curve key is not valid for sign/verify"
		Errors

	const ErrInvalidCurveSeed nkeysError = "nkeys: not a valid curve seed"
		Errors

	const ErrInvalidEncoding nkeysError = "nkeys: invalid encoded key"
		Errors

	const ErrInvalidEncrypted nkeysError = "nkeys: encrypted input is not valid"
		Errors

	const ErrInvalidEncVersion nkeysError = "nkeys: encrypted input wrong version"
		Errors

	const ErrInvalidKey nkeysError = "nkeys: invalid key"
		Errors

	const ErrInvalidNKeyOperation nkeysError = "nkeys: only curve key can seal/open"
		Errors

	const ErrInvalidNkeySeed nkeysError = "nkeys: doesn't contain a seed nkey"
		Errors

	const ErrInvalidPrefixByte nkeysError = "nkeys: invalid prefix byte"
		Errors

	const ErrInvalidPrivateKey nkeysError = "nkeys: invalid private key"
		Errors

	const ErrInvalidPublicKey nkeysError = "nkeys: invalid public key"
		Errors

	const ErrInvalidRecipient nkeysError = "nkeys: not a valid recipient public curve key"
		Errors

	const ErrInvalidSeed nkeysError = "nkeys: invalid seed"
		Errors

	const ErrInvalidSeedLen nkeysError = "nkeys: invalid seed length"
		Errors

	const ErrInvalidSender nkeysError = "nkeys: not a valid sender public curve key"
		Errors

	const ErrInvalidSignature nkeysError = "nkeys: signature verification failed"
		Errors

	const ErrInvalidUserSeed nkeysError = "nkeys: doesn't contain an user seed nkey"
		Errors

	const ErrNoSeedFound nkeysError = "nkeys: no nkey seed found"
		Errors

	const ErrPublicKeyOnly nkeysError = "nkeys: no seed or private key available"
		Errors

	const PrefixByteAccount PrefixByte = 0 // Base32-encodes to 'A...'
		PrefixByteAccount is the version byte used for encoded NATS Accounts

	const PrefixByteCluster PrefixByte = 16 // Base32-encodes to 'C...'
		PrefixByteCluster is the version byte used for encoded NATS Clusters

	const PrefixByteCurve PrefixByte = 184 // Base32-encodes to 'X...'
		PrefixByteCurve is the version byte used for encoded CurveKeys (X25519)

	const PrefixByteOperator PrefixByte = 112 // Base32-encodes to 'O...'
		PrefixByteOperator is the version byte used for encoded NATS Operators

	const PrefixBytePrivate PrefixByte = 120 // Base32-encodes to 'P...'
		PrefixBytePrivate is the version byte used for encoded NATS Private keys

	const PrefixByteSeed PrefixByte = 144 // Base32-encodes to 'S...'
		PrefixByteSeed is the version byte used for encoded NATS Seeds

	const PrefixByteServer PrefixByte = 104 // Base32-encodes to 'N...'
		PrefixByteServer is the version byte used for encoded NATS Servers

	const PrefixByteUnknown PrefixByte = 200 // Base32-encodes to 'Z...'
		PrefixByteUnknown is for unknown prefixes.

	const PrefixByteUser PrefixByte = 160 // Base32-encodes to 'U...'
		PrefixByteUser is the version byte used for encoded NATS Users

	const Version = "0.4.7"
		Version is our current version

	const XKeyVersionV1 = "xkv1"
		Only version for now, but could add in X3DH in the future, etc.

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.