package packet

Import Path
	golang.org/x/crypto/openpgp/packet (on go.dev)

Dependency Relation
	imports 36 packages, and imported by one package

Involved Source Files

	      compressed.go
	      config.go
	      encrypted_key.go
	      literal.go
	      ocfb.go
	      one_pass_signature.go
	      opaque.go
	   d➜ packet.go
		Package packet implements parsing and serialization of OpenPGP packets, as
		specified in RFC 4880.

	      private_key.go
	      public_key.go
	      public_key_v3.go
	      reader.go
	      signature.go
	      signature_v3.go
	      symmetric_key_encrypted.go
	      symmetrically_encrypted.go
	      userattribute.go
	      userid.go
Package-Level Type Names (total 44, in which 25 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type CipherFunction uint8 (basic type)
		CipherFunction represents the different block ciphers specified for OpenPGP. See
		http://www.iana.org/assignments/pgp-parameters/pgp-parameters.xhtml#pgp-parameters-13

		Methods (total 3, in which 1 are exported)
			( T) KeySize() int
				KeySize returns the key size, in bytes, of cipher.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			( T) blockSize() int
				blockSize returns the block size, in bytes, of cipher.

			( T) new(key []byte) (block cipher.Block)
				new returns a fresh instance of the given cipher.

		As Outputs Of (at least 2, both are exported)
			func (*Config).Cipher() CipherFunction
			func (*SymmetricKeyEncrypted).Decrypt(passphrase []byte) ([]byte, CipherFunction, error)
		As Inputs Of (at least 3, all are exported)
			func SerializeEncryptedKey(w io.Writer, pub *PublicKey, cipherFunc CipherFunction, key []byte, config *Config) error
			func SerializeSymmetricallyEncrypted(w io.Writer, c CipherFunction, key []byte, config *Config) (contents io.WriteCloser, err error)
			func (*SymmetricallyEncrypted).Decrypt(c CipherFunction, key []byte) (io.ReadCloser, error)
		As Types Of (total 5, all are exported)
			const Cipher3DES
			const CipherAES128
			const CipherAES192
			const CipherAES256
			const CipherCAST5

	 type Compressed (struct)
		Compressed represents a compressed OpenPGP packet. The decompressed contents
		will contain more OpenPGP packets. See RFC 4880, section 5.6.

		Fields (only one, which is exported)
			Body io.Reader
		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) error
		Implements (at least one exported)
			*T : Packet

	 type CompressionAlgo uint8 (basic type)
		CompressionAlgo Represents the different compression algorithms
		supported by OpenPGP (except for BZIP2, which is not currently
		supported). See Section 9.3 of RFC 4880.

		As Outputs Of (at least one exported)
			func (*Config).Compression() CompressionAlgo
		As Inputs Of (at least one exported)
			func SerializeCompressed(w io.WriteCloser, algo CompressionAlgo, cc *CompressionConfig) (literaldata io.WriteCloser, err error)
		As Types Of (total 3, all are exported)
			const CompressionNone
			const CompressionZIP
			const CompressionZLIB

	 type CompressionConfig (struct)
		CompressionConfig contains compressor configuration settings.

		Fields (only one, which is exported)
			Level int
				Level is the compression level to use. It must be set to
				between -1 and 9, with -1 causing the compressor to use the
				default compression level, 0 causing the compressor to use
				no compression and 1 to 9 representing increasing (better,
				slower) compression levels. If Level is less than -1 or
				more then 9, a non-nil error will be returned during
				encryption. See the constants above for convenient common
				settings for Level.

		As Inputs Of (at least one exported)
			func SerializeCompressed(w io.WriteCloser, algo CompressionAlgo, cc *CompressionConfig) (literaldata io.WriteCloser, err error)

	 type Config (struct)
		Config collects a number of parameters along with sensible defaults.
		A nil *Config is valid and results in all default values.

		Fields (total 8, all are exported)
			CompressionConfig *CompressionConfig
				CompressionConfig configures the compression settings.

			DefaultCipher CipherFunction
				DefaultCipher is the cipher to be used.
				If zero, AES-128 is used.

			DefaultCompressionAlgo CompressionAlgo
				DefaultCompressionAlgo is the compression algorithm to be
				applied to the plaintext before encryption. If zero, no
				compression is done.

			DefaultHash crypto.Hash
				DefaultHash is the default hash function to be used.
				If zero, SHA-256 is used.

			RSABits int
				RSABits is the number of bits in new RSA keys made with NewEntity.
				If zero, then 2048 bit keys are created.

			Rand io.Reader
				Rand provides the source of entropy.
				If nil, the crypto/rand Reader is used.

			S2KCount int
				S2KCount is only used for symmetric encryption. It
				determines the strength of the passphrase stretching when
				the said passphrase is hashed to produce a key. S2KCount
				should be between 1024 and 65011712, inclusive. If Config
				is nil or S2KCount is 0, the value 65536 used. Not all
				values in the above range can be represented. S2KCount will
				be rounded up to the next representable value if it cannot
				be encoded exactly. When set, it is strongly encrouraged to
				use a value that is at least 65536. See RFC 4880 Section
				3.7.1.3.

			Time func() time.Time
				Time returns the current time as the number of seconds since the
				epoch. If Time is nil, time.Now is used.

		Methods (total 6, all are exported)
			(*T) Cipher() CipherFunction
			(*T) Compression() CompressionAlgo
			(*T) Hash() crypto.Hash
			(*T) Now() time.Time
			(*T) PasswordHashIterations() int
			(*T) Random() io.Reader
		As Inputs Of (at least 21, in which 18 are exported)
			func SerializeEncryptedKey(w io.Writer, pub *PublicKey, cipherFunc CipherFunction, key []byte, config *Config) error
			func SerializeSymmetricallyEncrypted(w io.Writer, c CipherFunction, key []byte, config *Config) (contents io.WriteCloser, err error)
			func SerializeSymmetricKeyEncrypted(w io.Writer, passphrase []byte, config *Config) (key []byte, err error)
			func (*EncryptedKey).Decrypt(priv *PrivateKey, config *Config) error
			func (*Signature).Sign(h hash.Hash, priv *PrivateKey, config *Config) (err error)
			func (*Signature).SignKey(pub *PublicKey, priv *PrivateKey, config *Config) error
			func (*Signature).SignUserId(id string, pub *PublicKey, priv *PrivateKey, config *Config) error
			func golang.org/x/crypto/openpgp.ArmoredDetachSign(w io.Writer, signer *openpgp.Entity, message io.Reader, config *Config) (err error)
			func golang.org/x/crypto/openpgp.ArmoredDetachSignText(w io.Writer, signer *openpgp.Entity, message io.Reader, config *Config) error
			func golang.org/x/crypto/openpgp.DetachSign(w io.Writer, signer *openpgp.Entity, message io.Reader, config *Config) error
			func golang.org/x/crypto/openpgp.DetachSignText(w io.Writer, signer *openpgp.Entity, message io.Reader, config *Config) error
			func golang.org/x/crypto/openpgp.Encrypt(ciphertext io.Writer, to []*openpgp.Entity, signed *openpgp.Entity, hints *openpgp.FileHints, config *Config) (plaintext io.WriteCloser, err error)
			func golang.org/x/crypto/openpgp.NewEntity(name, comment, email string, config *Config) (*openpgp.Entity, error)
			func golang.org/x/crypto/openpgp.ReadMessage(r io.Reader, keyring openpgp.KeyRing, prompt openpgp.PromptFunction, config *Config) (md *openpgp.MessageDetails, err error)
			func golang.org/x/crypto/openpgp.Sign(output io.Writer, signed *openpgp.Entity, hints *openpgp.FileHints, config *Config) (input io.WriteCloser, err error)
			func golang.org/x/crypto/openpgp.SymmetricallyEncrypt(ciphertext io.Writer, passphrase []byte, hints *openpgp.FileHints, config *Config) (plaintext io.WriteCloser, err error)
			func golang.org/x/crypto/openpgp.(*Entity).SerializePrivate(w io.Writer, config *Config) (err error)
			func golang.org/x/crypto/openpgp.(*Entity).SignIdentity(identity string, signer *openpgp.Entity, config *Config) error
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func golang.org/x/crypto/openpgp.armoredDetachSign(w io.Writer, signer *openpgp.Entity, message io.Reader, sigType SignatureType, config *Config) (err error)
			func golang.org/x/crypto/openpgp.detachSign(w io.Writer, signer *openpgp.Entity, message io.Reader, sigType SignatureType, config *Config) (err error)
			func golang.org/x/crypto/openpgp.writeAndSign(payload io.WriteCloser, candidateHashes []uint8, signed *openpgp.Entity, hints *openpgp.FileHints, config *Config) (plaintext io.WriteCloser, err error)

	 type EncryptedKey (struct)
		EncryptedKey represents a public-key encrypted session key. See RFC 4880,
		section 5.1.

		Fields (total 6, in which 4 are exported)
			Algo PublicKeyAlgorithm
			CipherFunc CipherFunction
				// only valid after a successful Decrypt

			Key []byte
				// only valid after a successful Decrypt

			KeyId uint64
			/* 2 unexporteds ... *//* 2 unexporteds: */
			encryptedMPI1 parsedMPI
			encryptedMPI2 parsedMPI
		Methods (total 3, in which 2 are exported)
			(*T) Decrypt(priv *PrivateKey, config *Config) error
				Decrypt decrypts an encrypted session key with the given private key. The
				private key must have been decrypted first.
				If config is nil, sensible defaults will be used.

			(*T) Serialize(w io.Writer) error
				Serialize writes the encrypted key packet, e, to w.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet

	 type LiteralData (struct)
		LiteralData represents an encrypted file. See RFC 4880, section 5.9.

		Fields (total 4, all are exported)
			Body io.Reader
			FileName string
			IsBinary bool
			Time uint32
				// Unix epoch time. Either creation time or modification time. 0 means undefined.

		Methods (total 2, in which 1 are exported)
			(*T) ForEyesOnly() bool
				ForEyesOnly returns whether the contents of the LiteralData have been marked
				as especially sensitive.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet

	 type OCFBResyncOption bool (basic type)
		An OCFBResyncOption determines if the "resynchronization step" of OCFB is
		performed.

		As Inputs Of (at least 2, both are exported)
			func NewOCFBDecrypter(block cipher.Block, prefix []byte, resync OCFBResyncOption) cipher.Stream
			func NewOCFBEncrypter(block cipher.Block, randData []byte, resync OCFBResyncOption) (cipher.Stream, []byte)
		As Types Of (total 2, both are exported)
			const OCFBNoResync
			const OCFBResync

	 type OnePassSignature (struct)
		OnePassSignature represents a one-pass signature packet. See RFC 4880,
		section 5.4.

		Fields (total 5, all are exported)
			Hash crypto.Hash
			IsLast bool
			KeyId uint64
			PubKeyAlgo PublicKeyAlgorithm
			SigType SignatureType
		Methods (total 2, in which 1 are exported)
			(*T) Serialize(w io.Writer) error
				Serialize marshals the given OnePassSignature to w.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet

	 type OpaquePacket (struct)
		OpaquePacket represents an OpenPGP packet as raw, unparsed data. This is
		useful for splitting and storing the original packet contents separately,
		handling unsupported packet types or accessing parts of the packet not yet
		implemented by this package.

		Fields (total 3, all are exported)
			Contents []byte
				Binary contents of the packet data

			Reason error
				Reason why the packet was parsed opaquely

			Tag uint8
				Packet type

		Methods (total 3, in which 2 are exported)
			(*T) Parse() (p Packet, err error)
				Parse attempts to parse the opaque contents into a structure supported by
				this package. If the packet is not known then the result will be another
				OpaquePacket.

			(*T) Serialize(w io.Writer) (err error)
				Serialize marshals the packet to a writer in its original form, including
				the packet header.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet
		As Outputs Of (at least one exported)
			func (*OpaqueReader).Next() (op *OpaquePacket, err error)

	 type OpaqueReader (struct)
		OpaqueReader reads OpaquePackets from an io.Reader.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			r io.Reader
		Methods (only one, which is exported)
			(*T) Next() (op *OpaquePacket, err error)
				Read the next OpaquePacket.

		As Outputs Of (at least one exported)
			func NewOpaqueReader(r io.Reader) *OpaqueReader

	 type OpaqueSubpacket (struct)
		OpaqueSubpacket represents an unparsed OpenPGP subpacket,
		as found in signature and user attribute packets.

		Fields (total 2, both are exported)
			Contents []byte
			SubType uint8
		Methods (only one, which is exported)
			(*T) Serialize(w io.Writer) (err error)
		As Outputs Of (at least 2, in which 1 are exported)
			func OpaqueSubpackets(contents []byte) (result []*OpaqueSubpacket, err error)
			/* at least one unexported ... *//* at least one unexported: */
			func nextSubpacket(contents []byte) (subHeaderLen int, subPacket *OpaqueSubpacket, err error)
		As Inputs Of (at least one exported)
			func NewUserAttribute(contents ...*OpaqueSubpacket) *UserAttribute

	 type Packet (interface)
		Packet represents an OpenPGP packet. Users are expected to try casting
		instances of this interface to specific packet types.

		Methods (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			( T) parse(io.Reader) error
		Implemented By (at least 16, in which 14 are exported)
			*Compressed
			*EncryptedKey
			*LiteralData
			*OnePassSignature
			*OpaquePacket
			*PrivateKey
			*PublicKey
			*PublicKeyV3
			*Signature
			*SignatureV3
			*SymmetricallyEncrypted
			*SymmetricKeyEncrypted
			*UserAttribute
			*UserId
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*ecdhKdf
			*ecdsaKey
		As Outputs Of (at least 3, all are exported)
			func Read(r io.Reader) (p Packet, err error)
			func (*OpaquePacket).Parse() (p Packet, err error)
			func (*Reader).Next() (p Packet, err error)
		As Inputs Of (at least one exported)
			func (*Reader).Unread(p Packet)

	 type PrivateKey (struct)
		PrivateKey represents a possibly encrypted private key. See RFC 4880,
		section 5.5.3.

		Fields (total 21, in which 8 are exported)
			Encrypted bool
				// if true then the private key is unavailable until Decrypt has been called.

			PrivateKey interface{}
				// An *{rsa|dsa|ecdsa}.PrivateKey or crypto.Signer/crypto.Decrypter (Decryptor RSA only).

			PublicKey PublicKey
			PublicKey.CreationTime time.Time
			PublicKey.Fingerprint [20]byte
			PublicKey.IsSubkey bool
			PublicKey.KeyId uint64
			PublicKey.PubKeyAlgo PublicKeyAlgorithm
			/* 13 unexporteds ... *//* 13 unexporteds: */
			cipher CipherFunction
			encryptedData []byte
			iv []byte
			PublicKey.e parsedMPI
			PublicKey.ec *ecdsaKey
				RFC 6637 fields

			PublicKey.ecdh *ecdhKdf
			PublicKey.g parsedMPI
			PublicKey.n parsedMPI
			PublicKey.p parsedMPI
			PublicKey.q parsedMPI
			PublicKey.y parsedMPI
			s2k func(out, in []byte)
			sha1Checksum bool
		Methods (total 24, in which 13 are exported)
			(*T) BitLength() (bitLength uint16, err error)
				BitLength returns the bit length for the given public key.

			(*T) CanSign() bool
				CanSign returns true iff this public key can generate signatures

			(*T) Decrypt(passphrase []byte) error
				Decrypt decrypts an encrypted private key using a passphrase.

			(*T) KeyIdShortString() string
				KeyIdShortString returns the short form of public key's fingerprint
				in capital hex, as shown by gpg --list-keys (e.g. "621CC013").

			(*T) KeyIdString() string
				KeyIdString returns the public key's fingerprint in capital hex
				(e.g. "6C7EE1B8621CC013").

			(*T) Serialize(w io.Writer) (err error)
			(*T) SerializeSignaturePrefix(h io.Writer)
				SerializeSignaturePrefix writes the prefix for this public key to the given Writer.
				The prefix is used when calculating a signature over this public key. See
				RFC 4880, section 5.2.4.

			(*T) VerifyKeySignature(signed *PublicKey, sig *Signature) error
				VerifyKeySignature returns nil iff sig is a valid signature, made by this
				public key, of signed.

			(*T) VerifyRevocationSignature(sig *Signature) (err error)
				VerifyRevocationSignature returns nil iff sig is a valid signature, made by this
				public key.

			(*T) VerifySignature(signed hash.Hash, sig *Signature) (err error)
				VerifySignature returns nil iff sig is a valid signature, made by this
				public key, of the data hashed into signed. signed is mutated by this call.

			(*T) VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (err error)
				VerifySignatureV3 returns nil iff sig is a valid signature, made by this
				public key, of the data hashed into signed. signed is mutated by this call.

			(*T) VerifyUserIdSignature(id string, pub *PublicKey, sig *Signature) (err error)
				VerifyUserIdSignature returns nil iff sig is a valid signature, made by this
				public key, that id is the identity of pub.

			(*T) VerifyUserIdSignatureV3(id string, pub *PublicKey, sig *SignatureV3) (err error)
				VerifyUserIdSignatureV3 returns nil iff sig is a valid signature, made by this
				public key, that id is the identity of pub.

			/* 11 unexporteds ... *//* 11 unexporteds: */
			(*T) parse(r io.Reader) (err error)
			(*T) parseDSA(r io.Reader) (err error)
				parseDSA parses DSA public key material from the given Reader. See RFC 4880,
				section 5.5.2.

			(*T) parseDSAPrivateKey(data []byte) (err error)
			(*T) parseECDSAPrivateKey(data []byte) (err error)
			(*T) parseElGamal(r io.Reader) (err error)
				parseElGamal parses ElGamal public key material from the given Reader. See
				RFC 4880, section 5.5.2.

			(*T) parseElGamalPrivateKey(data []byte) (err error)
			(*T) parsePrivateKey(data []byte) (err error)
			(*T) parseRSA(r io.Reader) (err error)
				parseRSA parses RSA public key material from the given Reader. See RFC 4880,
				section 5.5.2.

			(*T) parseRSAPrivateKey(data []byte) (err error)
			(*T) serializeWithoutHeaders(w io.Writer) (err error)
				serializeWithoutHeaders marshals the PublicKey to w in the form of an
				OpenPGP public key packet, not including the packet header.

			(*T) setFingerPrintAndKeyId()
		Implements (at least 2, in which 1 are exported)
			*T : Packet
			/* at least one unexported ... *//* at least one unexported: */
			*T : signingKey
		As Outputs Of (at least 5, all are exported)
			func NewDSAPrivateKey(creationTime time.Time, priv *dsa.PrivateKey) *PrivateKey
			func NewECDSAPrivateKey(creationTime time.Time, priv *ecdsa.PrivateKey) *PrivateKey
			func NewElGamalPrivateKey(creationTime time.Time, priv *elgamal.PrivateKey) *PrivateKey
			func NewRSAPrivateKey(creationTime time.Time, priv *rsa.PrivateKey) *PrivateKey
			func NewSignerPrivateKey(creationTime time.Time, signer crypto.Signer) *PrivateKey
		As Inputs Of (at least 5, in which 4 are exported)
			func (*EncryptedKey).Decrypt(priv *PrivateKey, config *Config) error
			func (*Signature).Sign(h hash.Hash, priv *PrivateKey, config *Config) (err error)
			func (*Signature).SignKey(pub *PublicKey, priv *PrivateKey, config *Config) error
			func (*Signature).SignUserId(id string, pub *PublicKey, priv *PrivateKey, config *Config) error
			/* at least one unexported ... *//* at least one unexported: */
			func golang.org/x/crypto/openpgp.addSubkey(e *openpgp.Entity, packets *Reader, pub *PublicKey, priv *PrivateKey) error

	 type PublicKey (struct)
		PublicKey represents an OpenPGP public key. See RFC 4880, section 5.5.2.

		Fields (total 14, in which 6 are exported)
			CreationTime time.Time
			Fingerprint [20]byte
			IsSubkey bool
			KeyId uint64
			PubKeyAlgo PublicKeyAlgorithm
			PublicKey interface{}
				// *rsa.PublicKey, *dsa.PublicKey or *ecdsa.PublicKey

			/* 8 unexporteds ... *//* 8 unexporteds: */
			e parsedMPI
			ec *ecdsaKey
				RFC 6637 fields

			ecdh *ecdhKdf
			g parsedMPI
			n parsedMPI
			p parsedMPI
			q parsedMPI
			y parsedMPI
		Methods (total 18, in which 12 are exported)
			(*T) BitLength() (bitLength uint16, err error)
				BitLength returns the bit length for the given public key.

			(*T) CanSign() bool
				CanSign returns true iff this public key can generate signatures

			(*T) KeyIdShortString() string
				KeyIdShortString returns the short form of public key's fingerprint
				in capital hex, as shown by gpg --list-keys (e.g. "621CC013").

			(*T) KeyIdString() string
				KeyIdString returns the public key's fingerprint in capital hex
				(e.g. "6C7EE1B8621CC013").

			(*T) Serialize(w io.Writer) (err error)
			(*T) SerializeSignaturePrefix(h io.Writer)
				SerializeSignaturePrefix writes the prefix for this public key to the given Writer.
				The prefix is used when calculating a signature over this public key. See
				RFC 4880, section 5.2.4.

			(*T) VerifyKeySignature(signed *PublicKey, sig *Signature) error
				VerifyKeySignature returns nil iff sig is a valid signature, made by this
				public key, of signed.

			(*T) VerifyRevocationSignature(sig *Signature) (err error)
				VerifyRevocationSignature returns nil iff sig is a valid signature, made by this
				public key.

			(*T) VerifySignature(signed hash.Hash, sig *Signature) (err error)
				VerifySignature returns nil iff sig is a valid signature, made by this
				public key, of the data hashed into signed. signed is mutated by this call.

			(*T) VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (err error)
				VerifySignatureV3 returns nil iff sig is a valid signature, made by this
				public key, of the data hashed into signed. signed is mutated by this call.

			(*T) VerifyUserIdSignature(id string, pub *PublicKey, sig *Signature) (err error)
				VerifyUserIdSignature returns nil iff sig is a valid signature, made by this
				public key, that id is the identity of pub.

			(*T) VerifyUserIdSignatureV3(id string, pub *PublicKey, sig *SignatureV3) (err error)
				VerifyUserIdSignatureV3 returns nil iff sig is a valid signature, made by this
				public key, that id is the identity of pub.

			/* 6 unexporteds ... *//* 6 unexporteds: */
			(*T) parse(r io.Reader) (err error)
			(*T) parseDSA(r io.Reader) (err error)
				parseDSA parses DSA public key material from the given Reader. See RFC 4880,
				section 5.5.2.

			(*T) parseElGamal(r io.Reader) (err error)
				parseElGamal parses ElGamal public key material from the given Reader. See
				RFC 4880, section 5.5.2.

			(*T) parseRSA(r io.Reader) (err error)
				parseRSA parses RSA public key material from the given Reader. See RFC 4880,
				section 5.5.2.

			(*T) serializeWithoutHeaders(w io.Writer) (err error)
				serializeWithoutHeaders marshals the PublicKey to w in the form of an
				OpenPGP public key packet, not including the packet header.

			(*T) setFingerPrintAndKeyId()
		Implements (at least 2, in which 1 are exported)
			*T : Packet
			/* at least one unexported ... *//* at least one unexported: */
			*T : signingKey
		As Outputs Of (at least 4, all are exported)
			func NewDSAPublicKey(creationTime time.Time, pub *dsa.PublicKey) *PublicKey
			func NewECDSAPublicKey(creationTime time.Time, pub *ecdsa.PublicKey) *PublicKey
			func NewElGamalPublicKey(creationTime time.Time, pub *elgamal.PublicKey) *PublicKey
			func NewRSAPublicKey(creationTime time.Time, pub *rsa.PublicKey) *PublicKey
		As Inputs Of (at least 8, in which 6 are exported)
			func SerializeEncryptedKey(w io.Writer, pub *PublicKey, cipherFunc CipherFunction, key []byte, config *Config) error
			func (*PublicKey).VerifyKeySignature(signed *PublicKey, sig *Signature) error
			func (*PublicKey).VerifyUserIdSignature(id string, pub *PublicKey, sig *Signature) (err error)
			func (*PublicKey).VerifyUserIdSignatureV3(id string, pub *PublicKey, sig *SignatureV3) (err error)
			func (*Signature).SignKey(pub *PublicKey, priv *PrivateKey, config *Config) error
			func (*Signature).SignUserId(id string, pub *PublicKey, priv *PrivateKey, config *Config) error
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func userIdSignatureHash(id string, pk *PublicKey, hashFunc crypto.Hash) (h hash.Hash, err error)
			func golang.org/x/crypto/openpgp.addSubkey(e *openpgp.Entity, packets *Reader, pub *PublicKey, priv *PrivateKey) error

	 type PublicKeyAlgorithm uint8 (basic type)
		PublicKeyAlgorithm represents the different public key system specified for
		OpenPGP. See
		http://www.iana.org/assignments/pgp-parameters/pgp-parameters.xhtml#pgp-parameters-12

		Methods (total 2, both are exported)
			( T) CanEncrypt() bool
				CanEncrypt returns true if it's possible to encrypt a message to a public
				key of the given type.

			( T) CanSign() bool
				CanSign returns true if it's possible for a public key of the given type to
				sign a message.

		As Types Of (total 7, all are exported)
			const PubKeyAlgoDSA
			const PubKeyAlgoECDH
			const PubKeyAlgoECDSA
			const PubKeyAlgoElGamal
			const PubKeyAlgoRSA
			const PubKeyAlgoRSAEncryptOnly
			const PubKeyAlgoRSASignOnly

	 type PublicKeyV3 (struct)
		PublicKeyV3 represents older, version 3 public keys. These keys are less secure and
		should not be used for signing or encrypting. They are supported here only for
		parsing version 3 key material and validating signatures.
		See RFC 4880, section 5.5.2.

		Fields (total 9, in which 7 are exported)
			CreationTime time.Time
			DaysToExpire uint16
			Fingerprint [16]byte
			IsSubkey bool
			KeyId uint64
			PubKeyAlgo PublicKeyAlgorithm
			PublicKey *rsa.PublicKey
			/* 2 unexporteds ... *//* 2 unexporteds: */
			e parsedMPI
			n parsedMPI
		Methods (total 13, in which 9 are exported)
			(*T) BitLength() (bitLength uint16, err error)
				BitLength returns the bit length for the given public key.

			(*T) CanSign() bool
				CanSign returns true iff this public key can generate signatures

			(*T) KeyIdShortString() string
				KeyIdShortString returns the short form of public key's fingerprint
				in capital hex, as shown by gpg --list-keys (e.g. "621CC013").

			(*T) KeyIdString() string
				KeyIdString returns the public key's fingerprint in capital hex
				(e.g. "6C7EE1B8621CC013").

			(*T) Serialize(w io.Writer) (err error)
			(*T) SerializeSignaturePrefix(w io.Writer)
				SerializeSignaturePrefix writes the prefix for this public key to the given Writer.
				The prefix is used when calculating a signature over this public key. See
				RFC 4880, section 5.2.4.

			(*T) VerifyKeySignatureV3(signed *PublicKeyV3, sig *SignatureV3) (err error)
				VerifyKeySignatureV3 returns nil iff sig is a valid signature, made by this
				public key, of signed.

			(*T) VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (err error)
				VerifySignatureV3 returns nil iff sig is a valid signature, made by this
				public key, of the data hashed into signed. signed is mutated by this call.

			(*T) VerifyUserIdSignatureV3(id string, pub *PublicKeyV3, sig *SignatureV3) (err error)
				VerifyUserIdSignatureV3 returns nil iff sig is a valid signature, made by this
				public key, that id is the identity of pub.

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) parse(r io.Reader) (err error)
			(*T) parseRSA(r io.Reader) (err error)
				parseRSA parses RSA public key material from the given Reader. See RFC 4880,
				section 5.5.2.

			(*T) serializeWithoutHeaders(w io.Writer) (err error)
				serializeWithoutHeaders marshals the PublicKey to w in the form of an
				OpenPGP public key packet, not including the packet header.

			(*T) setFingerPrintAndKeyId()
		Implements (at least 2, in which 1 are exported)
			*T : Packet
			/* at least one unexported ... *//* at least one unexported: */
			*T : signingKey
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newRSAPublicKeyV3(creationTime time.Time, pub *rsa.PublicKey) *PublicKeyV3
		As Inputs Of (at least 2, both are exported)
			func (*PublicKeyV3).VerifyKeySignatureV3(signed *PublicKeyV3, sig *SignatureV3) (err error)
			func (*PublicKeyV3).VerifyUserIdSignatureV3(id string, pub *PublicKeyV3, sig *SignatureV3) (err error)

	 type Reader (struct)
		Reader reads packets from an io.Reader and allows packets to be 'unread' so
		that they result from the next call to Next.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			q []Packet
			readers []io.Reader
		Methods (total 3, all are exported)
			(*T) Next() (p Packet, err error)
				Next returns the most recently unread Packet, or reads another packet from
				the top-most io.Reader. Unknown packet types are skipped.

			(*T) Push(reader io.Reader) (err error)
				Push causes the Reader to start reading from a new io.Reader. When an EOF
				error is seen from the new io.Reader, it is popped and the Reader continues
				to read from the next most recent io.Reader. Push returns a StructuralError
				if pushing the reader would exceed the maximum recursion level, otherwise it
				returns nil.

			(*T) Unread(p Packet)
				Unread causes the given Packet to be returned from the next call to Next.

		As Outputs Of (at least one exported)
			func NewReader(r io.Reader) *Reader
		As Inputs Of (at least 5, in which 1 are exported)
			func golang.org/x/crypto/openpgp.ReadEntity(packets *Reader) (*openpgp.Entity, error)
			/* 4+ unexporteds ... *//* 4+ unexporteds: */
			func golang.org/x/crypto/openpgp.addSubkey(e *openpgp.Entity, packets *Reader, pub *PublicKey, priv *PrivateKey) error
			func golang.org/x/crypto/openpgp.addUserID(e *openpgp.Entity, packets *Reader, pkt *UserId) error
			func golang.org/x/crypto/openpgp.readSignedMessage(packets *Reader, mdin *openpgp.MessageDetails, keyring openpgp.KeyRing) (md *openpgp.MessageDetails, err error)
			func golang.org/x/crypto/openpgp.readToNextPublicKey(packets *Reader) (err error)

	 type Signature (struct)
		Signature represents a signature. See RFC 4880, section 5.2.

		Fields (total 29, in which 27 are exported)
			CreationTime time.Time
			DSASigR parsedMPI
			DSASigS parsedMPI
			ECDSASigR parsedMPI
			ECDSASigS parsedMPI
			EmbeddedSignature *Signature
				EmbeddedSignature, if non-nil, is a signature of the parent key, by
				this key. This prevents an attacker from claiming another's signing
				subkey as their own.

			FlagCertify bool
			FlagEncryptCommunications bool
			FlagEncryptStorage bool
			FlagSign bool
			FlagsValid bool
				FlagsValid is set if any flags were given. See RFC 4880, section
				5.2.3.21 for details.

			Hash crypto.Hash
			HashSuffix []byte
				HashSuffix is extra data that is hashed in after the signed data.

			HashTag [2]byte
				HashTag contains the first two bytes of the hash for fast rejection
				of bad signed data.

			IsPrimaryId *bool
			IssuerKeyId *uint64
			KeyLifetimeSecs *uint32
			MDC bool
				MDC is set if this signature has a feature packet that indicates
				support for MDC subpackets.

			PreferredCompression []uint8
			PreferredHash []uint8
			PreferredSymmetric []uint8
			PubKeyAlgo PublicKeyAlgorithm
			RSASignature parsedMPI
			RevocationReason *uint8
				RevocationReason is set if this signature has been revoked.
				See RFC 4880, section 5.2.3.23 for details.

			RevocationReasonText string
			SigLifetimeSecs *uint32
			SigType SignatureType
			/* 2 unexporteds ... *//* 2 unexporteds: */
			outSubpackets []outputSubpacket
			rawSubpackets []outputSubpacket
				rawSubpackets contains the unparsed subpackets, in order.

		Methods (total 9, in which 5 are exported)
			(*T) KeyExpired(currentTime time.Time) bool
				KeyExpired returns whether sig is a self-signature of a key that has
				expired.

			(*T) Serialize(w io.Writer) (err error)
				Serialize marshals sig to w. Sign, SignUserId or SignKey must have been
				called first.

			(*T) Sign(h hash.Hash, priv *PrivateKey, config *Config) (err error)
				Sign signs a message with a private key. The hash, h, must contain
				the hash of the message to be signed and will be mutated by this function.
				On success, the signature is stored in sig. Call Serialize to write it out.
				If config is nil, sensible defaults will be used.

			(*T) SignKey(pub *PublicKey, priv *PrivateKey, config *Config) error
				SignKey computes a signature from priv, asserting that pub is a subkey. On
				success, the signature is stored in sig. Call Serialize to write it out.
				If config is nil, sensible defaults will be used.

			(*T) SignUserId(id string, pub *PublicKey, priv *PrivateKey, config *Config) error
				SignUserId computes a signature from priv, asserting that pub is a valid
				key for the identity id.  On success, the signature is stored in sig. Call
				Serialize to write it out.
				If config is nil, sensible defaults will be used.

			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) buildHashSuffix() (err error)
				buildHashSuffix constructs the HashSuffix member of sig in preparation for signing.

			(*T) buildSubpackets() (subpackets []outputSubpacket)
			(*T) parse(r io.Reader) (err error)
			(*T) signPrepareHash(h hash.Hash) (digest []byte, err error)
		Implements (at least one exported)
			*T : Packet
		As Inputs Of (at least 7, in which 4 are exported)
			func (*PublicKey).VerifyKeySignature(signed *PublicKey, sig *Signature) error
			func (*PublicKey).VerifyRevocationSignature(sig *Signature) (err error)
			func (*PublicKey).VerifySignature(signed hash.Hash, sig *Signature) (err error)
			func (*PublicKey).VerifyUserIdSignature(id string, pub *PublicKey, sig *Signature) (err error)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func parseSignatureSubpacket(sig *Signature, subpacket []byte, isHashed bool) (rest []byte, err error)
			func parseSignatureSubpackets(sig *Signature, subpackets []byte, isHashed bool) (err error)
			func golang.org/x/crypto/openpgp.shouldReplaceSubkeySig(existingSig, potentialNewSig *Signature) bool

	 type SignatureType uint8 (basic type)
		SignatureType represents the different semantic meanings of an OpenPGP
		signature. See RFC 4880, section 5.2.1.

		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func golang.org/x/crypto/openpgp.armoredDetachSign(w io.Writer, signer *openpgp.Entity, message io.Reader, sigType SignatureType, config *Config) (err error)
			func golang.org/x/crypto/openpgp.detachSign(w io.Writer, signer *openpgp.Entity, message io.Reader, sigType SignatureType, config *Config) (err error)
			func golang.org/x/crypto/openpgp.hashForSignature(hashId crypto.Hash, sigType SignatureType) (hash.Hash, hash.Hash, error)
		As Types Of (only one, which is exported)
			const SigTypeBinary

	 type SignatureV3 (struct)
		SignatureV3 represents older version 3 signatures. These signatures are less secure
		than version 4 and should not be used to create new signatures. They are included
		here for backwards compatibility to read and validate with older key material.
		See RFC 4880, section 5.2.2.

		Fields (total 9, all are exported)
			CreationTime time.Time
			DSASigR parsedMPI
			DSASigS parsedMPI
			Hash crypto.Hash
			HashTag [2]byte
			IssuerKeyId uint64
			PubKeyAlgo PublicKeyAlgorithm
			RSASignature parsedMPI
			SigType SignatureType
		Methods (total 2, in which 1 are exported)
			(*T) Serialize(w io.Writer) (err error)
				Serialize marshals sig to w. Sign, SignUserId or SignKey must have been
				called first.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet
		As Inputs Of (at least 5, all are exported)
			func (*PublicKey).VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (err error)
			func (*PublicKey).VerifyUserIdSignatureV3(id string, pub *PublicKey, sig *SignatureV3) (err error)
			func (*PublicKeyV3).VerifyKeySignatureV3(signed *PublicKeyV3, sig *SignatureV3) (err error)
			func (*PublicKeyV3).VerifySignatureV3(signed hash.Hash, sig *SignatureV3) (err error)
			func (*PublicKeyV3).VerifyUserIdSignatureV3(id string, pub *PublicKeyV3, sig *SignatureV3) (err error)

	 type SymmetricallyEncrypted (struct)
		SymmetricallyEncrypted represents a symmetrically encrypted byte string. The
		encrypted contents will consist of more OpenPGP packets. See RFC 4880,
		sections 5.7 and 5.13.

		Fields (total 3, in which 1 are exported)
			MDC bool
				// true iff this is a type 18 packet and thus has an embedded MAC.

			/* 2 unexporteds ... *//* 2 unexporteds: */
			contents io.Reader
			prefix []byte
		Methods (total 2, in which 1 are exported)
			(*T) Decrypt(c CipherFunction, key []byte) (io.ReadCloser, error)
				Decrypt returns a ReadCloser, from which the decrypted contents of the
				packet can be read. An incorrect key can, with high probability, be detected
				immediately and this will result in a KeyIncorrect error being returned.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) error
		Implements (at least one exported)
			*T : Packet

	 type SymmetricKeyEncrypted (struct)
		SymmetricKeyEncrypted represents a passphrase protected session key. See RFC
		4880, section 5.3.

		Fields (total 3, in which 1 are exported)
			CipherFunc CipherFunction
			/* 2 unexporteds ... *//* 2 unexporteds: */
			encryptedKey []byte
			s2k func(out, in []byte)
		Methods (total 2, in which 1 are exported)
			(*T) Decrypt(passphrase []byte) ([]byte, CipherFunction, error)
				Decrypt attempts to decrypt an encrypted session key and returns the key and
				the cipher to use when decrypting a subsequent Symmetrically Encrypted Data
				packet.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) error
		Implements (at least one exported)
			*T : Packet

	 type UserAttribute (struct)
		UserAttribute is capable of storing other types of data about a user
		beyond name, email and a text comment. In practice, user attributes are typically used
		to store a signed thumbnail photo JPEG image of the user.
		See RFC 4880, section 5.12.

		Fields (only one, which is exported)
			Contents []*OpaqueSubpacket
		Methods (total 3, in which 2 are exported)
			(*T) ImageData() (imageData [][]byte)
				ImageData returns zero or more byte slices, each containing
				JPEG File Interchange Format (JFIF), for each photo in the
				user attribute packet.

			(*T) Serialize(w io.Writer) (err error)
				Serialize marshals the user attribute to w in the form of an OpenPGP packet, including
				header.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet
		As Outputs Of (at least 2, both are exported)
			func NewUserAttribute(contents ...*OpaqueSubpacket) *UserAttribute
			func NewUserAttributePhoto(photos ...image.Image) (uat *UserAttribute, err error)

	 type UserId (struct)
		UserId contains text that is intended to represent the name and email
		address of the key holder. See RFC 4880, section 5.11. By convention, this
		takes the form "Full Name (Comment) <email@example.com>"

		Fields (total 4, all are exported)
			Comment string
			Email string
			Id string
				// By convention, this takes the form "Full Name (Comment) <email@example.com>" which is split out in the fields below.

			Name string
		Methods (total 2, in which 1 are exported)
			(*T) Serialize(w io.Writer) error
				Serialize marshals uid to w in the form of an OpenPGP packet, including
				header.

			/* one unexported ... *//* one unexported: */
			(*T) parse(r io.Reader) (err error)
		Implements (at least one exported)
			*T : Packet
		As Outputs Of (at least one exported)
			func NewUserId(name, comment, email string) *UserId
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func golang.org/x/crypto/openpgp.addUserID(e *openpgp.Entity, packets *Reader, pkt *UserId) error

	/* 19 unexporteds ... *//* 19 unexporteds: */
	 type compressedWriteCloser (struct)
		compressedWriterCloser represents the serialized compression stream
		header and the compressor. Its Close() method ensures that both the
		compressor and serialized stream header are closed. Its Write()
		method writes to the compressor.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			c io.WriteCloser
				// Compressor

			sh io.Closer
				// Stream Header

		Methods (total 2, both are exported)
			( T) Close() (err error)
			( T) Write(p []byte) (int, error)
		Implements (at least 5, all are exported)
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Writer
			 T : io.Closer
			 T : io.WriteCloser
			 T : io.Writer

	 type ecdhKdf (struct)
		ecdhKdf stores key derivation function parameters
		used for ECDH encryption. See RFC 6637, Section 9.

		Fields (total 2, both are exported)
			KdfAlgo kdfAlgorithm
			KdfHash kdfHashFunction
		Methods (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			(*T) byteLen() int
			(*T) parse(r io.Reader) (err error)
			(*T) serialize(w io.Writer) (err error)
		Implements (at least one exported)
			*T : Packet

	 type ecdsaKey (struct)
		ecdsaKey stores the algorithm-specific fields for ECDSA keys.
		as defined in RFC 6637, Section 9.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			oid []byte
				oid contains the OID byte sequence identifying the elliptic curve used

			p parsedMPI
				p contains the elliptic curve point that represents the public key

		Methods (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			(*T) byteLen() int
			(*T) newECDSA() (*ecdsa.PublicKey, error)
			(*T) parse(r io.Reader) (err error)
			(*T) serialize(w io.Writer) (err error)
		Implements (at least one exported)
			*T : Packet

	 type kdfAlgorithm byte (basic type)
	 type kdfHashFunction byte (basic type)
	 type noOpCloser (struct)
		noOpCloser is like an ioutil.NopCloser, but for an io.Writer.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			w io.Writer
		Methods (total 2, both are exported)
			( T) Close() error
			( T) Write(data []byte) (n int, err error)
		Implements (at least 5, all are exported)
			 T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			 T : github.com/jbenet/go-context/io.Writer
			 T : io.Closer
			 T : io.WriteCloser
			 T : io.Writer

	 type ocfbDecrypter (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			b cipher.Block
			fre []byte
			outUsed int
		Methods (only one, which is exported)
			(*T) XORKeyStream(dst, src []byte)
		Implements (at least one exported)
			*T : crypto/cipher.Stream

	 type ocfbEncrypter (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			b cipher.Block
			fre []byte
			outUsed int
		Methods (only one, which is exported)
			(*T) XORKeyStream(dst, src []byte)
		Implements (at least one exported)
			*T : crypto/cipher.Stream

	 type outputSubpacket (struct)
		outputSubpacket represents a subpacket to be marshaled.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			contents []byte
			hashed bool
				// true if this subpacket is in the hashed area.

			isCritical bool
			subpacketType signatureSubpacketType
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Signature).buildSubpackets() (subpackets []outputSubpacket)
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func serializeSubpackets(to []byte, subpackets []outputSubpacket, hashed bool)
			func subpacketsLength(subpackets []outputSubpacket, hashed bool) (length int)

	 type packetType uint8 (basic type)
		packetType represents the numeric ids of the different OpenPGP packet types. See
		http://www.iana.org/assignments/pgp-parameters/pgp-parameters.xhtml#pgp-parameters-2

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func readHeader(r io.Reader) (tag packetType, length int64, contents io.Reader, err error)
		As Inputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func serializeHeader(w io.Writer, ptype packetType, length int) (err error)
			func serializeStreamHeader(w io.WriteCloser, ptype packetType) (out io.WriteCloser, err error)
		As Types Of (total 14, none are exported)
			/* 14 unexporteds ... *//* 14 unexporteds: */
			const packetTypeCompressed
			const packetTypeEncryptedKey
			const packetTypeLiteralData
			const packetTypeOnePassSignature
			const packetTypePrivateKey
			const packetTypePrivateSubkey
			const packetTypePublicKey
			const packetTypePublicSubkey
			const packetTypeSignature
			const packetTypeSymmetricallyEncrypted
			const packetTypeSymmetricallyEncryptedMDC
			const packetTypeSymmetricKeyEncrypted
			const packetTypeUserAttribute
			const packetTypeUserId

	 type parsedMPI (struct)
		A parsedMPI is used to store the contents of a big integer, along with the
		bit length that was specified in the original input. This allows the MPI to
		be reserialized exactly.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			bitLength uint16
			bytes []byte
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func fromBig(n *big.Int) parsedMPI
		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func writeMPIs(w io.Writer, mpis ...parsedMPI) (err error)

	 type partialLengthReader (struct)
		partialLengthReader wraps an io.Reader and handles OpenPGP partial lengths.
		The continuation lengths are parsed and removed from the stream and EOF is
		returned at the end of the packet. See RFC 4880, section 4.2.2.4.

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			isPartial bool
			r io.Reader
			remaining int64
		Methods (only one, which is exported)
			(*T) Read(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Reader

	 type partialLengthWriter (struct)
		partialLengthWriter writes a stream of data using OpenPGP partial lengths.
		See RFC 4880, section 4.2.2.4.

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			buf []byte
			lengthByte [1]byte
			sentFirst bool
			w io.WriteCloser
		Methods (total 2, both are exported)
			(*T) Close() error
			(*T) Write(p []byte) (n int, err error)
		Implements (at least 5, all are exported)
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Closer
			*T : io.WriteCloser
			*T : io.Writer

	 type seMDCReader (struct)
		An seMDCReader wraps an io.Reader, maintains a running hash and keeps hold
		of the most recent 22 bytes (mdcTrailerSize). Upon EOF, those bytes form an
		MDC packet containing a hash of the previous contents which is checked
		against the running hash. See RFC 4880, section 5.13.

		Fields (total 7, none are exported)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			eof bool
			error bool
			h hash.Hash
			in io.Reader
			scratch [22]byte
			trailer [22]byte
			trailerUsed int
		Methods (total 2, both are exported)
			(*T) Close() error
			(*T) Read(buf []byte) (n int, err error)
		Implements (at least 4, all are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Closer
			*T : io.ReadCloser
			*T : io.Reader

	 type seMDCWriter (struct)
		An seMDCWriter writes through to an io.WriteCloser while maintains a running
		hash of the data written. On close, it emits an MDC packet containing the
		running hash.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			h hash.Hash
			w io.WriteCloser
		Methods (total 2, both are exported)
			(*T) Close() (err error)
			(*T) Write(buf []byte) (n int, err error)
		Implements (at least 5, all are exported)
			*T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress
			*T : github.com/jbenet/go-context/io.Writer
			*T : io.Closer
			*T : io.WriteCloser
			*T : io.Writer

	 type seReader (struct)
		seReader wraps an io.Reader with a no-op Close method.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			in io.Reader
		Methods (total 2, both are exported)
			( T) Close() error
			( T) Read(buf []byte) (int, error)
		Implements (at least 4, all are exported)
			 T : github.com/jbenet/go-context/io.Reader
			 T : io.Closer
			 T : io.ReadCloser
			 T : io.Reader

	 type signatureSubpacketType uint8 (basic type)

		As Types Of (total 12, none are exported)
			/* 12 unexporteds ... *//* 12 unexporteds: */
			const creationTimeSubpacket
			const embeddedSignatureSubpacket
			const featuresSubpacket
			const issuerSubpacket
			const keyExpirationSubpacket
			const keyFlagsSubpacket
			const prefCompressionSubpacket
			const prefHashAlgosSubpacket
			const prefSymmetricAlgosSubpacket
			const primaryUserIdSubpacket
			const reasonForRevocationSubpacket
			const signatureExpirationSubpacket

	 type signingKey (interface)
		signingKey provides a convenient abstraction over signature verification
		for v3 and v4 public keys.

		Methods (total 2, in which 1 are exported)
			( T) SerializeSignaturePrefix(io.Writer)
			/* one unexported ... *//* one unexported: */
			( T) serializeWithoutHeaders(io.Writer) error
		Implemented By (at least 3, all are exported)
			*PrivateKey
			*PublicKey
			*PublicKeyV3
		As Inputs Of (at least 3, none are exported)
			/* 3+ unexporteds ... *//* 3+ unexporteds: */
			func keyRevocationHash(pk signingKey, hashFunc crypto.Hash) (h hash.Hash, err error)
			func keySignatureHash(pk, signed signingKey, hashFunc crypto.Hash) (h hash.Hash, err error)
			func userIdSignatureV3Hash(id string, pk signingKey, hfn crypto.Hash) (h hash.Hash, err error)

	 type spanReader (struct)
		A spanReader is an io.LimitReader, but it returns ErrUnexpectedEOF if the
		underlying Reader returns EOF before the limit has been reached.

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			n int64
			r io.Reader
		Methods (only one, which is exported)
			(*T) Read(p []byte) (n int, err error)
		Implements (at least 2, both are exported)
			*T : github.com/jbenet/go-context/io.Reader
			*T : io.Reader


Package-Level Functions (total 60, in which 23 are exported)

	 func NewDSAPrivateKey(creationTime time.Time, priv *dsa.PrivateKey) *PrivateKey
	 func NewDSAPublicKey(creationTime time.Time, pub *dsa.PublicKey) *PublicKey
		NewDSAPublicKey returns a PublicKey that wraps the given dsa.PublicKey.

	 func NewECDSAPrivateKey(creationTime time.Time, priv *ecdsa.PrivateKey) *PrivateKey
	 func NewECDSAPublicKey(creationTime time.Time, pub *ecdsa.PublicKey) *PublicKey
	 func NewElGamalPrivateKey(creationTime time.Time, priv *elgamal.PrivateKey) *PrivateKey
	 func NewElGamalPublicKey(creationTime time.Time, pub *elgamal.PublicKey) *PublicKey
		NewElGamalPublicKey returns a PublicKey that wraps the given elgamal.PublicKey.

	 func NewOCFBDecrypter(block cipher.Block, prefix []byte, resync OCFBResyncOption) cipher.Stream
		NewOCFBDecrypter returns a cipher.Stream which decrypts data with OpenPGP's
		cipher feedback mode using the given cipher.Block. Prefix must be the first
		blockSize + 2 bytes of the ciphertext, where blockSize is the cipher.Block's
		block size. If an incorrect key is detected then nil is returned. On
		successful exit, blockSize+2 bytes of decrypted data are written into
		prefix. Resync determines if the "resynchronization step" from RFC 4880,
		13.9 step 7 is performed. Different parts of OpenPGP vary on this point.

	 func NewOCFBEncrypter(block cipher.Block, randData []byte, resync OCFBResyncOption) (cipher.Stream, []byte)
		NewOCFBEncrypter returns a cipher.Stream which encrypts data with OpenPGP's
		cipher feedback mode using the given cipher.Block, and an initial amount of
		ciphertext.  randData must be random bytes and be the same length as the
		cipher.Block's block size. Resync determines if the "resynchronization step"
		from RFC 4880, 13.9 step 7 is performed. Different parts of OpenPGP vary on
		this point.

	 func NewOpaqueReader(r io.Reader) *OpaqueReader
	 func NewReader(r io.Reader) *Reader
	 func NewRSAPrivateKey(creationTime time.Time, priv *rsa.PrivateKey) *PrivateKey
	 func NewRSAPublicKey(creationTime time.Time, pub *rsa.PublicKey) *PublicKey
		NewRSAPublicKey returns a PublicKey that wraps the given rsa.PublicKey.

	 func NewSignerPrivateKey(creationTime time.Time, signer crypto.Signer) *PrivateKey
		NewSignerPrivateKey creates a PrivateKey from a crypto.Signer that
		implements RSA or ECDSA.

	 func NewUserAttribute(contents ...*OpaqueSubpacket) *UserAttribute
		NewUserAttribute creates a new user attribute packet containing the given subpackets.

	 func NewUserAttributePhoto(photos ...image.Image) (uat *UserAttribute, err error)
		NewUserAttributePhoto creates a user attribute packet
		containing the given images.

	 func NewUserId(name, comment, email string) *UserId
		NewUserId returns a UserId or nil if any of the arguments contain invalid
		characters. The invalid characters are '\x00', '(', ')', '<' and '>'

	 func OpaqueSubpackets(contents []byte) (result []*OpaqueSubpacket, err error)
		OpaqueSubpackets extracts opaque, unparsed OpenPGP subpackets from
		their byte representation.

	 func Read(r io.Reader) (p Packet, err error)
		Read reads a single OpenPGP packet from the given io.Reader. If there is an
		error parsing a packet, the whole packet is consumed from the input.

	 func SerializeCompressed(w io.WriteCloser, algo CompressionAlgo, cc *CompressionConfig) (literaldata io.WriteCloser, err error)
		SerializeCompressed serializes a compressed data packet to w and
		returns a WriteCloser to which the literal data packets themselves
		can be written and which MUST be closed on completion. If cc is
		nil, sensible defaults will be used to configure the compression
		algorithm.

	 func SerializeEncryptedKey(w io.Writer, pub *PublicKey, cipherFunc CipherFunction, key []byte, config *Config) error
		SerializeEncryptedKey serializes an encrypted key packet to w that contains
		key, encrypted to pub.
		If config is nil, sensible defaults will be used.

	 func SerializeLiteral(w io.WriteCloser, isBinary bool, fileName string, time uint32) (plaintext io.WriteCloser, err error)
		SerializeLiteral serializes a literal data packet to w and returns a
		WriteCloser to which the data itself can be written and which MUST be closed
		on completion. The fileName is truncated to 255 bytes.

	 func SerializeSymmetricallyEncrypted(w io.Writer, c CipherFunction, key []byte, config *Config) (contents io.WriteCloser, err error)
		SerializeSymmetricallyEncrypted serializes a symmetrically encrypted packet
		to w and returns a WriteCloser to which the to-be-encrypted packets can be
		written.
		If config is nil, sensible defaults will be used.

	 func SerializeSymmetricKeyEncrypted(w io.Writer, passphrase []byte, config *Config) (key []byte, err error)
		SerializeSymmetricKeyEncrypted serializes a symmetric key packet to w. The
		packet contains a random session key, encrypted by a key derived from the
		given passphrase. The session key is returned and must be passed to
		SerializeSymmetricallyEncrypted.
		If config is nil, sensible defaults will be used.

	/* 37 unexporteds ... *//* 37 unexporteds: */
	 func checksumKeyMaterial(key []byte) uint16
	 func consumeAll(r io.Reader) (n int64, err error)
		consumeAll reads from the given Reader until error, returning the number of
		bytes read.

	 func fromBig(n *big.Int) parsedMPI
	 func hasInvalidCharacters(s string) bool
	 func keyRevocationHash(pk signingKey, hashFunc crypto.Hash) (h hash.Hash, err error)
	 func keySignatureHash(pk, signed signingKey, hashFunc crypto.Hash) (h hash.Hash, err error)
		keySignatureHash returns a Hash of the message that needs to be signed for
		pk to assert a subkey relationship to signed.

	 func mod64kHash(d []byte) uint16
	 func newRSAPublicKeyV3(creationTime time.Time, pub *rsa.PublicKey) *PublicKeyV3
		newRSAPublicKeyV3 returns a PublicKey that wraps the given rsa.PublicKey.
		Included here for testing purposes only. RFC 4880, section 5.5.2:
		"an implementation MUST NOT generate a V3 key, but MAY accept it."

	 func nextSubpacket(contents []byte) (subHeaderLen int, subPacket *OpaqueSubpacket, err error)
	 func padToKeySize(pub *rsa.PublicKey, b []byte) []byte
		padToKeySize left-pads a MPI with zeroes to match the length of the
		specified RSA public.

	 func parseOID(r io.Reader) (oid []byte, err error)
		parseOID reads the OID for the curve as defined in RFC 6637, Section 9.

	 func parseSignatureSubpacket(sig *Signature, subpacket []byte, isHashed bool) (rest []byte, err error)
		parseSignatureSubpacket parses a single subpacket. len(subpacket) is >= 1.

	 func parseSignatureSubpackets(sig *Signature, subpackets []byte, isHashed bool) (err error)
		parseSignatureSubpackets parses subpackets of the main signature packet. See
		RFC 4880, section 5.2.3.1.

	 func parseUserId(id string) (name, comment, email string)
		parseUserId extracts the name, comment and email from a user id string that
		is formatted as "Full Name (Comment) <email@example.com>".

	 func peekVersion(r io.Reader) (bufr *bufio.Reader, ver byte, err error)
		peekVersion detects the version of a public key packet about to
		be read. A bufio.Reader at the original position of the io.Reader
		is returned.

	 func readFull(r io.Reader, buf []byte) (n int, err error)
		readFull is the same as io.ReadFull except that reading zero bytes returns
		ErrUnexpectedEOF rather than EOF.

	 func readHeader(r io.Reader) (tag packetType, length int64, contents io.Reader, err error)
		readHeader parses a packet header and returns an io.Reader which will return
		the contents of the packet. See RFC 4880, section 4.2.

	 func readLength(r io.Reader) (length int64, isPartial bool, err error)
		readLength reads an OpenPGP length from r. See RFC 4880, section 4.2.2.

	 func readMPI(r io.Reader) (mpi []byte, bitLength uint16, err error)
		readMPI reads a big integer from r. The bit length returned is the bit
		length that was specified in r. This is preserved so that the integer can be
		reserialized exactly.

	 func serializeDSAPrivateKey(w io.Writer, priv *dsa.PrivateKey) error
	 func serializeECDSAPrivateKey(w io.Writer, priv *ecdsa.PrivateKey) error
	 func serializeElGamalPrivateKey(w io.Writer, priv *elgamal.PrivateKey) error
	 func serializeEncryptedKeyElGamal(w io.Writer, rand io.Reader, header [10]byte, pub *elgamal.PublicKey, keyBlock []byte) error
	 func serializeEncryptedKeyRSA(w io.Writer, rand io.Reader, header [10]byte, pub *rsa.PublicKey, keyBlock []byte) error
	 func serializeHeader(w io.Writer, ptype packetType, length int) (err error)
		serializeHeader writes an OpenPGP packet header to w. See RFC 4880, section
		4.2.

	 func serializeRSAPrivateKey(w io.Writer, priv *rsa.PrivateKey) error
	 func serializeStreamHeader(w io.WriteCloser, ptype packetType) (out io.WriteCloser, err error)
		serializeStreamHeader writes an OpenPGP packet header to w where the
		length of the packet is unknown. It returns a io.WriteCloser which can be
		used to write the contents of the packet. See RFC 4880, section 4.2.

	 func serializeSubpacketLength(to []byte, length int) int
		serializeSubpacketLength marshals the given length into to.

	 func serializeSubpackets(to []byte, subpackets []outputSubpacket, hashed bool)
		serializeSubpackets marshals the given subpackets into to.

	 func subpacketLengthLength(length int) int
		subpacketLengthLength returns the length, in bytes, of an encoded length value.

	 func subpacketsLength(subpackets []outputSubpacket, hashed bool) (length int)
		subpacketsLength returns the serialized length, in bytes, of the given
		subpackets.

	 func unwrapECDSASig(b []byte) (r, s *big.Int, err error)
		unwrapECDSASig parses the two integer components of an ASN.1-encoded ECDSA
		signature.

	 func userIdSignatureHash(id string, pk *PublicKey, hashFunc crypto.Hash) (h hash.Hash, err error)
		userIdSignatureHash returns a Hash of the message that needs to be signed
		to assert that pk is a valid key for id.

	 func userIdSignatureV3Hash(id string, pk signingKey, hfn crypto.Hash) (h hash.Hash, err error)
		userIdSignatureV3Hash returns a Hash of the message that needs to be signed
		to assert that pk is a valid key for id.

	 func writeBig(w io.Writer, i *big.Int) error
		writeBig serializes a *big.Int to w.

	 func writeMPI(w io.Writer, bitLength uint16, mpiBytes []byte) (err error)
		writeMPI serializes a big integer to w.

	 func writeMPIs(w io.Writer, mpis ...parsedMPI) (err error)
		writeMPIs is a utility function for serializing several big integers to the
		given Writer.


Package-Level Variables (total 3, none are exported)

	/* 3 unexporteds ... *//* 3 unexporteds: */
	  var oidCurveP256 []byte
		NIST curve P-256

	  var oidCurveP384 []byte
		NIST curve P-384

	  var oidCurveP521 []byte
		NIST curve P-521


Package-Level Constants (total 73, in which 37 are exported)

	const BestCompression = 9
	const BestSpeed = 1
	const Cipher3DES CipherFunction = 2
	const CipherAES128 CipherFunction = 7
	const CipherAES192 CipherFunction = 8
	const CipherAES256 CipherFunction = 9
	const CipherCAST5 CipherFunction = 3
	const CompressionNone CompressionAlgo = 0
	const CompressionZIP CompressionAlgo = 1
	const CompressionZLIB CompressionAlgo = 2
	const DefaultCompression = -1
	const KeyFlagCertify = 1
		See RFC 4880, section 5.2.3.21 for details.

	const KeyFlagEncryptCommunications = 4
	const KeyFlagEncryptStorage = 8
	const KeyFlagSign = 2
	const NoCompression = 0
	const OCFBNoResync OCFBResyncOption = false
	const OCFBResync OCFBResyncOption = true
	const PubKeyAlgoDSA PublicKeyAlgorithm = 17
	const PubKeyAlgoECDH PublicKeyAlgorithm = 18
		RFC 6637, Section 5.

	const PubKeyAlgoECDSA PublicKeyAlgorithm = 19
	const PubKeyAlgoElGamal PublicKeyAlgorithm = 16
	const PubKeyAlgoRSA PublicKeyAlgorithm = 1
	const PubKeyAlgoRSAEncryptOnly PublicKeyAlgorithm = 2
		Deprecated in RFC 4880, Section 13.5. Use key flags instead.

	const PubKeyAlgoRSASignOnly PublicKeyAlgorithm = 3
	const SigTypeBinary SignatureType = 0
	const SigTypeCasualCert = 18
	const SigTypeDirectSignature = 31
	const SigTypeGenericCert = 16
	const SigTypeKeyRevocation = 32
	const SigTypePersonaCert = 17
	const SigTypePositiveCert = 19
	const SigTypePrimaryKeyBinding = 25
	const SigTypeSubkeyBinding = 24
	const SigTypeSubkeyRevocation = 40
	const SigTypeText = 1
	const UserAttrImageSubpacket = 1
	/* 36 unexporteds ... *//* 36 unexporteds: */
	const creationTimeSubpacket signatureSubpacketType = 2
	const embeddedSignatureSubpacket signatureSubpacketType = 32
	const encryptedKeyVersion = 3
	const featuresSubpacket signatureSubpacketType = 30
	const issuerSubpacket signatureSubpacketType = 16
	const keyExpirationSubpacket signatureSubpacketType = 9
	const keyFlagsSubpacket signatureSubpacketType = 27
	const maxOIDLength = 8
	const maxReaders = 32
		New io.Readers are pushed when a compressed or encrypted packet is processed
		and recursively treated as a new source of packets. However, a carefully
		crafted packet can trigger an infinite recursive sequence of packets. See
		http://mumble.net/~campbell/misc/pgp-quine
		https://web.nvd.nist.gov/view/vuln/detail?vulnId=CVE-2013-4402
		This constant limits the number of recursive packets that may be pushed.

	const maxSessionKeySizeInBytes = 64
		This is the largest session key that we'll support. Since no 512-bit cipher
		has even been seriously used, this is comfortably large.

	const mdcPacketTagByte byte = 211
		This is a new-format packet tag byte for a type 19 (MDC) packet.

	const mdcTrailerSize = 22
	const minFirstPartialWrite = 512
		RFC 4880 4.2.2.4: the first partial length MUST be at least 512 octets long.

	const onePassSignatureVersion = 3
	const packetTypeCompressed packetType = 8
	const packetTypeEncryptedKey packetType = 1
	const packetTypeLiteralData packetType = 11
	const packetTypeOnePassSignature packetType = 4
	const packetTypePrivateKey packetType = 5
	const packetTypePrivateSubkey packetType = 7
	const packetTypePublicKey packetType = 6
	const packetTypePublicSubkey packetType = 14
	const packetTypeSignature packetType = 2
	const packetTypeSymmetricallyEncrypted packetType = 9
	const packetTypeSymmetricallyEncryptedMDC packetType = 18
	const packetTypeSymmetricKeyEncrypted packetType = 3
	const packetTypeUserAttribute packetType = 17
	const packetTypeUserId packetType = 13
	const prefCompressionSubpacket signatureSubpacketType = 22
	const prefHashAlgosSubpacket signatureSubpacketType = 21
	const prefSymmetricAlgosSubpacket signatureSubpacketType = 11
	const primaryUserIdSubpacket signatureSubpacketType = 25
	const reasonForRevocationSubpacket signatureSubpacketType = 29
	const signatureExpirationSubpacket signatureSubpacketType = 3
	const symmetricallyEncryptedVersion = 1
	const symmetricKeyEncryptedVersion = 4

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin 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 @Go100and1 (reachable from the left QR code) to get the latest news of Golds.