package crypto

Import Path
	github.com/libp2p/go-libp2p/core/crypto (on go.dev)

Dependency Relation
	imports 22 packages, and imported by 20 packages

Involved Source Files

	    ecdsa.go
	    ed25519.go
	  d key.go
		Package crypto implements various cryptographic utilities used by libp2p.
		This includes a Public and Private key interface and key implementations
		for supported key algorithms.

	    key_to_stdlib.go
	    rsa_common.go
	    rsa_go.go
	    secp256k1.go
Package-Level Type Names (total 15)

	/* sort by: alphabet | popularity */
	 type ECDSAPrivateKey (struct)
		ECDSAPrivateKey is an implementation of an ECDSA private key

		Methods (total 5)
			(*ECDSAPrivateKey) Equals(o Key) bool
				Equals compares two private keys

			(*ECDSAPrivateKey) GetPublic() PubKey
				GetPublic returns a public key

			(*ECDSAPrivateKey) Raw() (res []byte, err error)
				Raw returns x509 bytes from a private key

			(*ECDSAPrivateKey) Sign(data []byte) (sig []byte, err error)
				Sign returns the signature of the input data

			(*ECDSAPrivateKey) Type() pb.KeyType
				Type returns the key type

		Implements (at least 2)
			*ECDSAPrivateKey : Key
			*ECDSAPrivateKey : PrivKey
		As Inputs Of (at least one exported)
			func MarshalECDSAPrivateKey(ePriv ECDSAPrivateKey) (res []byte, err error)

	 type ECDSAPublicKey (struct)
		ECDSAPublicKey is an implementation of an ECDSA public key

		Methods (total 4)
			(*ECDSAPublicKey) Equals(o Key) bool
				Equals compares to public keys

			(*ECDSAPublicKey) Raw() ([]byte, error)
				Raw returns x509 bytes from a public key

			(*ECDSAPublicKey) Type() pb.KeyType
				Type returns the key type

			(*ECDSAPublicKey) Verify(data, sigBytes []byte) (success bool, err error)
				Verify compares data to a signature

		Implements (at least 2)
			*ECDSAPublicKey : Key
			*ECDSAPublicKey : PubKey
		As Inputs Of (at least one exported)
			func MarshalECDSAPublicKey(ePub ECDSAPublicKey) (res []byte, err error)

	 type ECDSASig (struct)
		ECDSASig holds the r and s values of an ECDSA signature

		Fields (total 2)
			R *big.Int
			S *big.Int

	 type Ed25519PrivateKey (struct)
		Ed25519PrivateKey is an ed25519 private key.

		Methods (total 5)
			(*Ed25519PrivateKey) Equals(o Key) bool
				Equals compares two ed25519 private keys.

			(*Ed25519PrivateKey) GetPublic() PubKey
				GetPublic returns an ed25519 public key from a private key.

			(*Ed25519PrivateKey) Raw() ([]byte, error)
				Raw private key bytes.

			(*Ed25519PrivateKey) Sign(msg []byte) (res []byte, err error)
				Sign returns a signature from an input message.

			(*Ed25519PrivateKey) Type() pb.KeyType
				Type of the private key (Ed25519).

		Implements (at least 2)
			*Ed25519PrivateKey : Key
			*Ed25519PrivateKey : PrivKey

	 type Ed25519PublicKey (struct)
		Ed25519PublicKey is an ed25519 public key.

		Methods (total 4)
			(*Ed25519PublicKey) Equals(o Key) bool
				Equals compares two ed25519 public keys.

			(*Ed25519PublicKey) Raw() ([]byte, error)
				Raw public key bytes.

			(*Ed25519PublicKey) Type() pb.KeyType
				Type of the public key (Ed25519).

			(*Ed25519PublicKey) Verify(data []byte, sig []byte) (success bool, err error)
				Verify checks a signature against the input data.

		Implements (at least 2)
			*Ed25519PublicKey : Key
			*Ed25519PublicKey : PubKey

	 type GenSharedKey (func)
		GenSharedKey generates the shared key from a given private key

	 type Key (interface)
		Key represents a crypto key that can be compared to another key

		Methods (total 3)
			( Key) Equals(Key) bool
				Equals checks whether two PubKeys are the same

			( Key) Raw() ([]byte, error)
				Raw returns the raw bytes of the key (not wrapped in the
				libp2p-crypto protobuf).
				
				This function is the inverse of {Priv,Pub}KeyUnmarshaler.

			( Key) Type() pb.KeyType
				Type returns the protobuf key type.

		Implemented By (at least 10)
			*ECDSAPrivateKey
			*ECDSAPublicKey
			*Ed25519PrivateKey
			*Ed25519PublicKey
			 PrivKey (interface)
			 PubKey (interface)
			*RsaPrivateKey
			*RsaPublicKey
			*Secp256k1PrivateKey
			*Secp256k1PublicKey
		As Inputs Of (at least 12)
			func KeyEqual(k1, k2 Key) bool
			func (*ECDSAPrivateKey).Equals(o Key) bool
			func (*ECDSAPublicKey).Equals(o Key) bool
			func (*Ed25519PrivateKey).Equals(o Key) bool
			func (*Ed25519PublicKey).Equals(o Key) bool
			func Key.Equals(Key) bool
			func PrivKey.Equals(Key) bool
			func PubKey.Equals(Key) bool
			func (*RsaPrivateKey).Equals(k Key) bool
			func (*RsaPublicKey).Equals(k Key) bool
			func (*Secp256k1PrivateKey).Equals(o Key) bool
			func (*Secp256k1PublicKey).Equals(o Key) bool

	 type PrivKey (interface)
		PrivKey represents a private key that can be used to generate a public key and sign data

		Methods (total 5)
			( PrivKey) Equals(Key) bool
				Equals checks whether two PubKeys are the same

			( PrivKey) GetPublic() PubKey
				Return a public key paired with this private key

			( PrivKey) Raw() ([]byte, error)
				Raw returns the raw bytes of the key (not wrapped in the
				libp2p-crypto protobuf).
				
				This function is the inverse of {Priv,Pub}KeyUnmarshaler.

			( PrivKey) Sign([]byte) ([]byte, error)
				Cryptographically sign the given bytes

			( PrivKey) Type() pb.KeyType
				Type returns the protobuf key type.

		Implemented By (at least 4)
			*ECDSAPrivateKey
			*Ed25519PrivateKey
			*RsaPrivateKey
			*Secp256k1PrivateKey
		Implements (at least one exported)
			 PrivKey : Key
		As Outputs Of (at least 16)
			func ECDSAKeyPairFromKey(priv *ecdsa.PrivateKey) (PrivKey, PubKey, error)
			func GenerateECDSAKeyPair(src io.Reader) (PrivKey, PubKey, error)
			func GenerateECDSAKeyPairWithCurve(curve elliptic.Curve, src io.Reader) (PrivKey, PubKey, error)
			func GenerateEd25519Key(src io.Reader) (PrivKey, PubKey, error)
			func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error)
			func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error)
			func GenerateRSAKeyPair(bits int, src io.Reader) (PrivKey, PubKey, error)
			func GenerateSecp256k1Key(_ io.Reader) (PrivKey, PubKey, error)
			func KeyPairFromStdKey(priv crypto.PrivateKey) (PrivKey, PubKey, error)
			func UnmarshalECDSAPrivateKey(data []byte) (res PrivKey, err error)
			func UnmarshalEd25519PrivateKey(data []byte) (PrivKey, error)
			func UnmarshalPrivateKey(data []byte) (PrivKey, error)
			func UnmarshalRsaPrivateKey(b []byte) (key PrivKey, err error)
			func UnmarshalSecp256k1PrivateKey(data []byte) (k PrivKey, err error)
			func github.com/libp2p/go-libp2p/core/peerstore.KeyBook.PrivKey(peer.ID) PrivKey
			func github.com/libp2p/go-libp2p/core/peerstore.Peerstore.PrivKey(peer.ID) PrivKey
		As Inputs Of (at least 19)
			func MarshalPrivateKey(k PrivKey) ([]byte, error)
			func PrivKeyToStdKey(priv PrivKey) (crypto.PrivateKey, error)
			func github.com/libp2p/go-libp2p/core/peer.IDFromPrivateKey(sk PrivKey) (peer.ID, error)
			func github.com/libp2p/go-libp2p/core/peer.ID.MatchesPrivateKey(sk PrivKey) bool
			func github.com/libp2p/go-libp2p/core/peerstore.KeyBook.AddPrivKey(peer.ID, PrivKey) error
			func github.com/libp2p/go-libp2p/core/peerstore.Peerstore.AddPrivKey(peer.ID, PrivKey) error
			func github.com/libp2p/go-libp2p/core/record.Seal(rec record.Record, privateKey PrivKey) (*record.Envelope, error)
			func github.com/libp2p/go-libp2p/core/sec/insecure.NewWithIdentity(protocolID protocol.ID, id peer.ID, key PrivKey) *insecure.Transport
			func github.com/libp2p/go-libp2p.Identity(sk PrivKey) libp2p.Option
			func github.com/libp2p/go-libp2p/config.PrivKeyToStatelessResetKey(key PrivKey) (quic.StatelessResetKey, error)
			func github.com/libp2p/go-libp2p/config.PrivKeyToTokenGeneratorKey(key PrivKey) (quic.TokenGeneratorKey, error)
			func github.com/libp2p/go-libp2p/p2p/security/noise.New(id protocol.ID, privkey PrivKey, muxers []tptu.StreamMuxer) (*noise.Transport, error)
			func github.com/libp2p/go-libp2p/p2p/security/tls.GenerateSignedExtension(sk PrivKey, pubKey crypto.PublicKey) (pkix.Extension, error)
			func github.com/libp2p/go-libp2p/p2p/security/tls.New(id protocol.ID, key PrivKey, muxers []tptu.StreamMuxer) (*libp2ptls.Transport, error)
			func github.com/libp2p/go-libp2p/p2p/security/tls.NewIdentity(privKey PrivKey, opts ...libp2ptls.IdentityOption) (*libp2ptls.Identity, error)
			func github.com/libp2p/go-libp2p/p2p/transport/quic.NewTransport(key PrivKey, connManager *quicreuse.ConnManager, psk pnet.PSK, gater connmgr.ConnectionGater, rcmgr network.ResourceManager) (tpt.Transport, error)
			func github.com/libp2p/go-libp2p/p2p/transport/webrtc.New(privKey PrivKey, psk pnet.PSK, gater connmgr.ConnectionGater, rcmgr network.ResourceManager, listenUDP libp2pwebrtc.ListenUDPFn, opts ...libp2pwebrtc.Option) (*libp2pwebrtc.WebRTCTransport, error)
			func github.com/libp2p/go-libp2p/p2p/transport/webtransport.New(key PrivKey, psk pnet.PSK, connManager *quicreuse.ConnManager, gater connmgr.ConnectionGater, rcmgr network.ResourceManager, opts ...libp2pwebtransport.Option) (tpt.Transport, error)
			func github.com/libp2p/go-libp2p-pubsub.WithSecretKeyAndPeerId(key PrivKey, pid peer.ID) pubsub.PubOpt

	 type PrivKeyUnmarshaller (func)
		PrivKeyUnmarshaller is a func that creates a PrivKey from a given slice of bytes

	 type PubKey (interface)
		PubKey is a public key that can be used to verify data signed with the corresponding private key

		Methods (total 4)
			( PubKey) Equals(Key) bool
				Equals checks whether two PubKeys are the same

			( PubKey) Raw() ([]byte, error)
				Raw returns the raw bytes of the key (not wrapped in the
				libp2p-crypto protobuf).
				
				This function is the inverse of {Priv,Pub}KeyUnmarshaler.

			( PubKey) Type() pb.KeyType
				Type returns the protobuf key type.

			( PubKey) Verify(data []byte, sig []byte) (bool, error)
				Verify that 'sig' is the signed hash of 'data'

		Implemented By (at least 4)
			*ECDSAPublicKey
			*Ed25519PublicKey
			*RsaPublicKey
			*Secp256k1PublicKey
		Implements (at least one exported)
			 PubKey : Key
		As Outputs Of (at least 34)
			func ECDSAKeyPairFromKey(priv *ecdsa.PrivateKey) (PrivKey, PubKey, error)
			func ECDSAPublicKeyFromPubKey(pub ecdsa.PublicKey) (PubKey, error)
			func GenerateECDSAKeyPair(src io.Reader) (PrivKey, PubKey, error)
			func GenerateECDSAKeyPairWithCurve(curve elliptic.Curve, src io.Reader) (PrivKey, PubKey, error)
			func GenerateEd25519Key(src io.Reader) (PrivKey, PubKey, error)
			func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error)
			func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error)
			func GenerateRSAKeyPair(bits int, src io.Reader) (PrivKey, PubKey, error)
			func GenerateSecp256k1Key(_ io.Reader) (PrivKey, PubKey, error)
			func KeyPairFromStdKey(priv crypto.PrivateKey) (PrivKey, PubKey, error)
			func PublicKeyFromProto(pmes *pb.PublicKey) (PubKey, error)
			func UnmarshalECDSAPublicKey(data []byte) (key PubKey, err error)
			func UnmarshalEd25519PublicKey(data []byte) (PubKey, error)
			func UnmarshalPublicKey(data []byte) (PubKey, error)
			func UnmarshalRsaPublicKey(b []byte) (key PubKey, err error)
			func UnmarshalSecp256k1PublicKey(data []byte) (_k PubKey, err error)
			func (*ECDSAPrivateKey).GetPublic() PubKey
			func (*Ed25519PrivateKey).GetPublic() PubKey
			func PrivKey.GetPublic() PubKey
			func (*RsaPrivateKey).GetPublic() PubKey
			func (*Secp256k1PrivateKey).GetPublic() PubKey
			func github.com/libp2p/go-libp2p/core/network.Conn.RemotePublicKey() PubKey
			func github.com/libp2p/go-libp2p/core/network.ConnSecurity.RemotePublicKey() PubKey
			func github.com/libp2p/go-libp2p/core/peer.ID.ExtractPublicKey() (PubKey, error)
			func github.com/libp2p/go-libp2p/core/peerstore.KeyBook.PubKey(peer.ID) PubKey
			func github.com/libp2p/go-libp2p/core/peerstore.Peerstore.PubKey(peer.ID) PubKey
			func github.com/libp2p/go-libp2p/core/routing.GetPublicKey(r routing.ValueStore, ctx context.Context, p peer.ID) (PubKey, error)
			func github.com/libp2p/go-libp2p/core/routing.PubKeyFetcher.GetPublicKey(context.Context, peer.ID) (PubKey, error)
			func github.com/libp2p/go-libp2p/core/sec.SecureConn.RemotePublicKey() PubKey
			func github.com/libp2p/go-libp2p/core/sec/insecure.(*Conn).RemotePublicKey() PubKey
			func github.com/libp2p/go-libp2p/core/transport.CapableConn.RemotePublicKey() PubKey
			func github.com/libp2p/go-libp2p/p2p/net/swarm.(*Conn).RemotePublicKey() PubKey
			func github.com/libp2p/go-libp2p/p2p/security/tls.PubKeyFromCertChain(chain []*x509.Certificate) (PubKey, error)
			func github.com/libp2p/go-libp2p/p2p/security/tls.(*Identity).ConfigForPeer(remote peer.ID) (*tls.Config, <-chan PubKey)
		As Inputs Of (at least 8)
			func MarshalPublicKey(k PubKey) ([]byte, error)
			func PubKeyToStdKey(pub PubKey) (crypto.PublicKey, error)
			func PublicKeyToProto(k PubKey) (*pb.PublicKey, error)
			func github.com/libp2p/go-libp2p/core/peer.IDFromPublicKey(pk PubKey) (peer.ID, error)
			func github.com/libp2p/go-libp2p/core/peer.ID.MatchesPublicKey(pk PubKey) bool
			func github.com/libp2p/go-libp2p/core/peerstore.KeyBook.AddPubKey(peer.ID, PubKey) error
			func github.com/libp2p/go-libp2p/core/peerstore.Peerstore.AddPubKey(peer.ID, PubKey) error
			func github.com/libp2p/go-libp2p/p2p/net/swarm.MetricsTracer.OpenedConnection(network.Direction, PubKey, network.ConnectionState, ma.Multiaddr)

	 type PubKeyUnmarshaller (func)
		PubKeyUnmarshaller is a func that creates a PubKey from a given slice of bytes

	 type RsaPrivateKey (struct)
		RsaPrivateKey is a rsa private key

		Methods (total 5)
			(*RsaPrivateKey) Equals(k Key) bool
				Equals checks whether this key is equal to another

			(*RsaPrivateKey) GetPublic() PubKey
				GetPublic returns a public key

			(*RsaPrivateKey) Raw() (res []byte, err error)
			(*RsaPrivateKey) Sign(message []byte) (sig []byte, err error)
				Sign returns a signature of the input data

			(*RsaPrivateKey) Type() pb.KeyType
		Implements (at least 2)
			*RsaPrivateKey : Key
			*RsaPrivateKey : PrivKey

	 type RsaPublicKey (struct)
		RsaPublicKey is a rsa public key

		Methods (total 4)
			(*RsaPublicKey) Equals(k Key) bool
				Equals checks whether this key is equal to another

			(*RsaPublicKey) Raw() (res []byte, err error)
			(*RsaPublicKey) Type() pb.KeyType
			(*RsaPublicKey) Verify(data, sig []byte) (success bool, err error)
				Verify compares a signature against input data

		Implements (at least 2)
			*RsaPublicKey : Key
			*RsaPublicKey : PubKey

	 type Secp256k1PrivateKey secp256k1.PrivateKey (struct)
		Secp256k1PrivateKey is a Secp256k1 private key

		Fields (only one)
			Key secp256k1.ModNScalar
		Methods (total 5)
			(*Secp256k1PrivateKey) Equals(o Key) bool
				Equals compares two private keys

			(*Secp256k1PrivateKey) GetPublic() PubKey
				GetPublic returns a public key

			(*Secp256k1PrivateKey) Raw() ([]byte, error)
				Raw returns the bytes of the key

			(*Secp256k1PrivateKey) Sign(data []byte) (_sig []byte, err error)
				Sign returns a signature from input data

			(*Secp256k1PrivateKey) Type() pb.KeyType
				Type returns the private key type

		Implements (at least 2)
			*Secp256k1PrivateKey : Key
			*Secp256k1PrivateKey : PrivKey

	 type Secp256k1PublicKey secp256k1.PublicKey (struct)
		Secp256k1PublicKey is a Secp256k1 public key

		Methods (total 4)
			(*Secp256k1PublicKey) Equals(o Key) bool
				Equals compares two public keys

			(*Secp256k1PublicKey) Raw() (res []byte, err error)
				Raw returns the bytes of the key

			(*Secp256k1PublicKey) Type() pb.KeyType
				Type returns the public key type

			(*Secp256k1PublicKey) Verify(data []byte, sigStr []byte) (success bool, err error)
				Verify compares a signature against the input data

		Implements (at least 2)
			*Secp256k1PublicKey : Key
			*Secp256k1PublicKey : PubKey


Package-Level Functions (total 31)

	 func ConfigDecodeKey(b string) ([]byte, error)
		ConfigDecodeKey decodes from b64 (for config file) to a byte array that can be unmarshalled.

	 func ConfigEncodeKey(b []byte) string
		ConfigEncodeKey encodes a marshalled key to b64 (for config file).

	 func ECDSAKeyPairFromKey(priv *ecdsa.PrivateKey) (PrivKey, PubKey, error)
		ECDSAKeyPairFromKey generates a new ecdsa private and public key from an input private key

	 func ECDSAPublicKeyFromPubKey(pub ecdsa.PublicKey) (PubKey, error)
		ECDSAPublicKeyFromPubKey generates a new ecdsa public key from an input public key

	 func GenerateECDSAKeyPair(src io.Reader) (PrivKey, PubKey, error)
		GenerateECDSAKeyPair generates a new ecdsa private and public key

	 func GenerateECDSAKeyPairWithCurve(curve elliptic.Curve, src io.Reader) (PrivKey, PubKey, error)
		GenerateECDSAKeyPairWithCurve generates a new ecdsa private and public key with a specified curve

	 func GenerateEd25519Key(src io.Reader) (PrivKey, PubKey, error)
		GenerateEd25519Key generates a new ed25519 private and public key pair.

	 func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error)
		GenerateKeyPair generates a private and public key

	 func GenerateKeyPairWithReader(typ, bits int, src io.Reader) (PrivKey, PubKey, error)
		GenerateKeyPairWithReader returns a keypair of the given type and bit-size

	 func GenerateRSAKeyPair(bits int, src io.Reader) (PrivKey, PubKey, error)
		GenerateRSAKeyPair generates a new rsa private and public key

	 func GenerateSecp256k1Key(_ io.Reader) (PrivKey, PubKey, error)
		GenerateSecp256k1Key generates a new Secp256k1 private and public key pair

	 func KeyEqual(k1, k2 Key) bool
		KeyEqual checks whether two Keys are equivalent (have identical byte representations).

	 func KeyPairFromStdKey(priv crypto.PrivateKey) (PrivKey, PubKey, error)
		KeyPairFromStdKey wraps standard library (and secp256k1) private keys in libp2p/go-libp2p/core/crypto keys

	 func MarshalECDSAPrivateKey(ePriv ECDSAPrivateKey) (res []byte, err error)
		MarshalECDSAPrivateKey returns x509 bytes from a private key

	 func MarshalECDSAPublicKey(ePub ECDSAPublicKey) (res []byte, err error)
		MarshalECDSAPublicKey returns x509 bytes from a public key

	 func MarshalPrivateKey(k PrivKey) ([]byte, error)
		MarshalPrivateKey converts a key object into its protobuf serialized form.

	 func MarshalPublicKey(k PubKey) ([]byte, error)
		MarshalPublicKey converts a public key object into a protobuf serialized
		public key

	 func PrivKeyToStdKey(priv PrivKey) (crypto.PrivateKey, error)
		PrivKeyToStdKey converts libp2p/go-libp2p/core/crypto private keys to standard library (and secp256k1) private keys

	 func PubKeyToStdKey(pub PubKey) (crypto.PublicKey, error)
		PubKeyToStdKey converts libp2p/go-libp2p/core/crypto private keys to standard library (and secp256k1) public keys

	 func PublicKeyFromProto(pmes *pb.PublicKey) (PubKey, error)
		PublicKeyFromProto converts an unserialized protobuf PublicKey message
		into its representative object.

	 func PublicKeyToProto(k PubKey) (*pb.PublicKey, error)
		PublicKeyToProto converts a public key object into an unserialized
		protobuf PublicKey message.

	 func UnmarshalECDSAPrivateKey(data []byte) (res PrivKey, err error)
		UnmarshalECDSAPrivateKey returns a private key from x509 bytes

	 func UnmarshalECDSAPublicKey(data []byte) (key PubKey, err error)
		UnmarshalECDSAPublicKey returns the public key from x509 bytes

	 func UnmarshalEd25519PrivateKey(data []byte) (PrivKey, error)
		UnmarshalEd25519PrivateKey returns a private key from input bytes.

	 func UnmarshalEd25519PublicKey(data []byte) (PubKey, error)
		UnmarshalEd25519PublicKey returns a public key from input bytes.

	 func UnmarshalPrivateKey(data []byte) (PrivKey, error)
		UnmarshalPrivateKey converts a protobuf serialized private key into its
		representative object

	 func UnmarshalPublicKey(data []byte) (PubKey, error)
		UnmarshalPublicKey converts a protobuf serialized public key into its
		representative object

	 func UnmarshalRsaPrivateKey(b []byte) (key PrivKey, err error)
		UnmarshalRsaPrivateKey returns a private key from the input x509 bytes

	 func UnmarshalRsaPublicKey(b []byte) (key PubKey, err error)
		UnmarshalRsaPublicKey returns a public key from the input x509 bytes

	 func UnmarshalSecp256k1PrivateKey(data []byte) (k PrivKey, err error)
		UnmarshalSecp256k1PrivateKey returns a private key from bytes

	 func UnmarshalSecp256k1PublicKey(data []byte) (_k PubKey, err error)
		UnmarshalSecp256k1PublicKey returns a public key from bytes


Package-Level Variables (total 12)

	  var ECDSACurve elliptic.Curve
		ECDSACurve is the default ecdsa curve used

	  var ErrBadKeyType error
		ErrBadKeyType is returned when a key is not supported

	  var ErrNilPrivateKey error
		ErrNilPrivateKey is returned when a nil private key is provided

	  var ErrNilPublicKey error
		ErrNilPublicKey is returned when a nil public key is provided

	  var ErrNilSig error
		ErrNilSig is returned when the signature is nil

	  var ErrNotECDSAPubKey error
		ErrNotECDSAPubKey is returned when the public key passed is not an ecdsa public key

	  var ErrRsaKeyTooBig error
	  var ErrRsaKeyTooSmall error
		ErrRsaKeyTooSmall is returned when trying to generate or parse an RSA key
		that's smaller than MinRsaKeyBits bits. In test

	  var KeyTypes []int
		KeyTypes is a list of supported keys

	  var MinRsaKeyBits int
	  var PrivKeyUnmarshallers map[pb.KeyType]PrivKeyUnmarshaller
		PrivKeyUnmarshallers is a map of unmarshallers by key type

	  var PubKeyUnmarshallers map[pb.KeyType]PubKeyUnmarshaller
		PubKeyUnmarshallers is a map of unmarshallers by key type


Package-Level Constants (total 5)

	const ECDSA = 3
		ECDSA is an enum for the supported ECDSA key type

	const Ed25519 = 1
		Ed25519 is an enum for the supported Ed25519 key type

	const RSA = 0
		RSA is an enum for the supported RSA key type

	const Secp256k1 = 2
		Secp256k1 is an enum for the supported Secp256k1 key type

	const WeakRsaKeyEnv = "LIBP2P_ALLOW_WEAK_RSA_KEYS"
		WeakRsaKeyEnv is an environment variable which, when set, lowers the
		minimum required bits of RSA keys to 512. This should be used exclusively in
		test situations.

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.