Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
- API
  
  Reference documentation for the pkg.go.dev API
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

dialer

package

Go to main page

Versions in this module

v1

v1.37.9

Sep 23, 2026

v1.37.8

Sep 23, 2026

v1.37.7

Sep 17, 2026

v1.37.6

Sep 11, 2026

v1.37.5

Sep 11, 2026

v1.37.4

Sep 11, 2026

v1.37.3

Sep 9, 2026

v1.37.2

Sep 9, 2026

v1.37.1

Sep 8, 2026

Changes in this version

+ const AnnounceAppDataLenSz

+ const AnnounceDestLen

+ const AnnounceEd25519Len

+ const AnnounceHopsLen

+ const AnnounceMaxAppData

+ const AnnounceMinSize

+ const AnnounceSigLen

+ const AnnounceTimestampLen

+ const AnnounceX25519Len

+ const DefaultAnnounceExpiry

+ const DefaultAnnounceInterval

+ const DefaultDestTableSize

+ const DefaultMaxHops

+ const MsgTypeData

+ const MsgTypeKeyExchange

+ const MsgTypeLinkAccept

+ const MsgTypeLinkComplete

+ const MsgTypeLinkProof

+ const MsgTypeLinkRequest

+ var ErrAnnounceAppDataTooLarge = errors.New("announce: app data too large")

+ var ErrAnnounceDestMismatch = errors.New("announce: destination mismatch")

+ var ErrAnnounceExpired = errors.New("announce: expired")

+ var ErrAnnounceFutureTimestamp = errors.New("announce: timestamp in future")

+ var ErrAnnounceInvalidSignature = errors.New("announce: invalid signature")

+ var ErrAnnounceInvalidSize = errors.New("announce: invalid wire size")

+ var ErrAnnounceMaxHops = errors.New("announce: max hops exceeded")

+ var ErrAnnounceNoIdentity = errors.New("announce: identity not set")

+ var ErrDecryptionFailed = errors.New("decryption failed")

+ var ErrDestinationUnknown = errors.New("destination unknown")

+ var ErrHybridDecapsulationFailed = errors.New("hybrid decapsulation failed")

+ var ErrHybridSignatureInvalid = errors.New("hybrid signature verification failed")

+ var ErrInvalidHybridIdentity = errors.New("invalid hybrid identity")

+ var ErrInvalidIdentity = errors.New("invalid RNS identity")

+ var ErrInvalidSignature = errors.New("invalid signature")

+ var ErrLinkHandshakeFailed = errors.New("RNS link handshake failed")

+ var ErrLinkIntegrityFailed = errors.New("RNS link integrity check failed")

+ var ErrLinkKeyExchange = errors.New("RNS link key exchange failed")

+ var ErrRNSDialFailed = errors.New("RNS dial failed")

+ var ErrRNSLinkClosed = errors.New("RNS link closed")

+ var ErrRNSNotConfigured = errors.New("RNS transport not configured")

+ var ErrRNSTimeout = errors.New("RNS operation timed out")

+ var ErrZWingMissingIdentity = errors.New("zwing dialer: missing LocalIdentity")

+ func DestinationFromPublicKeys(edPublicKey, xPublicKey []byte) ([endpoints.RNSDestinationLen]byte, error)

+ func VerifyWithPubKey(publicKey, message, signature []byte) bool

+ func VerifyWithPublicKey(publicKey, message, signature []byte) bool

+ type Announce struct

+ AppData []byte

+ Destination [AnnounceDestLen]byte

+ Ed25519PubKey [AnnounceEd25519Len]byte

+ Hops uint8

+ Signature [AnnounceSigLen]byte

+ Timestamp int64

+ X25519PubKey [AnnounceX25519Len]byte

+ func UnmarshalAnnounce(data []byte) (*Announce, error)

+ func (a *Announce) Marshal() []byte

+ func (a *Announce) Sign(priv ed25519.PrivateKey)

+ func (a *Announce) SignableBytes() []byte

+ func (a *Announce) Verify() bool

+ func (a *Announce) VerifyDestination() bool

+ type AnnounceEntry struct

+ Destination [endpoints.RNSDestinationLen]byte

+ ExchangeKey [32]byte

+ ExpiresAt time.Time

+ Hops uint8

+ LastSeen time.Time

+ SigningKey ed25519.PublicKey

+ TransportAddr netip.AddrPort

+ type AnnounceHandler interface

+ OnAnnounce func(announce *Announce) error

+ type AnnounceHandlerFunc func(*Announce) error

+ func (f AnnounceHandlerFunc) OnAnnounce(a *Announce) error

+ type Announcer struct

+ func NewAnnouncer(config AnnouncerConfig, logger log.Logger) *Announcer

+ func (a *Announcer) AddHandler(h AnnounceHandler)

+ func (a *Announcer) CreateAnnounce() (*Announce, error)

+ func (a *Announcer) DestTable() *DestTable

+ func (a *Announcer) HandleReceived(data []byte) (*Announce, error)

+ func (a *Announcer) Lookup(dest [AnnounceDestLen]byte) *Announce

+ func (a *Announcer) SetBroadcastFunc(fn func(*Announce) error)

+ func (a *Announcer) SetIdentity(identity *RNSIdentity, appData []byte)

+ func (a *Announcer) Start()

+ func (a *Announcer) Stop()

+ func (a *Announcer) Validate(ann *Announce) error

+ type AnnouncerConfig struct

+ AnnounceExpiry time.Duration

+ AnnounceInterval time.Duration

+ ClockSkew time.Duration

+ DestTableSize int

+ MaxHops uint8

+ func DefaultAnnouncerConfig() AnnouncerConfig

+ type Config struct

+ ConnectionTimeout time.Duration

+ ThrottleRps uint32

+ type DNSCacheConfig struct

+ MaxEntries int

+ ResolveTimeout time.Duration

+ TTL time.Duration

+ func DefaultDNSCacheConfig() DNSCacheConfig

+ type DestTable struct

+ func NewDestTable(maxSize int, expiry time.Duration) *DestTable

+ func (t *DestTable) All() []*Announce

+ func (t *DestTable) Get(dest [AnnounceDestLen]byte) *Announce

+ func (t *DestTable) Len() int

+ func (t *DestTable) Prune() int

+ func (t *DestTable) Put(a *Announce) bool

+ func (t *DestTable) Remove(dest [AnnounceDestLen]byte)

+ type Dialer interface

+ Dial func(ctx context.Context, ip netip.AddrPort) (net.Conn, error)

+ func NewDialer(network string, dialerConfig Config, logger log.Logger) Dialer

+ type EndpointDialer interface

+ Dial func(ctx context.Context, ip netip.AddrPort) (net.Conn, error)

+ DialEndpoint func(ctx context.Context, endpoint endpoints.Endpoint) (net.Conn, error)

+ func NewEndpointDialer(network string, config EndpointDialerConfig, logger log.Logger) EndpointDialer

+ type EndpointDialerConfig struct

+ DNSConfig DNSCacheConfig

+ RNSTransport RNSTransport

+ type HybridIdentity struct

+ func LoadHybridIdentity(path string) (*HybridIdentity, error)

+ func LoadOrGenerateHybridIdentity(path string) (*HybridIdentity, error)

+ func NewHybridIdentity() (*HybridIdentity, error)

+ func (id *HybridIdentity) Close() error

+ func (id *HybridIdentity) Destination() [endpoints.RNSDestinationLen]byte

+ func (id *HybridIdentity) Hash() [endpoints.RNSDestinationLen]byte

+ func (id *HybridIdentity) HybridDecapsulate(ciphertext []byte) ([]byte, error)

+ func (id *HybridIdentity) HybridEncapsulate(recipientPub *HybridPublicIdentity) ([]byte, []byte, error)

+ func (id *HybridIdentity) HybridKEMPublicKey() []byte

+ func (id *HybridIdentity) IsHybrid() bool

+ func (id *HybridIdentity) MLDSAPublicKey() []byte

+ func (id *HybridIdentity) PublicIdentity() (*HybridPublicIdentity, error)

+ func (id *HybridIdentity) Save(path string) error

+ func (id *HybridIdentity) Sign(message []byte) ([]byte, error)

+ func (id *HybridIdentity) SignEd25519(message []byte) []byte

+ func (id *HybridIdentity) SignMLDSA(message []byte) ([]byte, error)

+ func (id *HybridIdentity) SigningPublicKey() []byte

+ func (id *HybridIdentity) ToClassicalIdentity() (*RNSIdentity, error)

+ func (id *HybridIdentity) Verify(message, signature []byte) bool

+ func (id *HybridIdentity) X25519PublicKey() [x25519KeySize]byte

+ type HybridPublicIdentity struct

+ func NewHybridPublicIdentity(edPubKey, xPubKey []byte, mldsaPubKey *mldsa.PublicKey, ...) (*HybridPublicIdentity, error)

+ func UnmarshalHybridPublicIdentity(data []byte) (*HybridPublicIdentity, error)

+ func (pub *HybridPublicIdentity) Destination() [endpoints.RNSDestinationLen]byte

+ func (pub *HybridPublicIdentity) HybridKEMPublicKey() []byte

+ func (pub *HybridPublicIdentity) MLDSAPublicKey() []byte

+ func (pub *HybridPublicIdentity) MarshalBinary() ([]byte, error)

+ func (pub *HybridPublicIdentity) SigningPublicKey() []byte

+ func (pub *HybridPublicIdentity) Verify(message, signature []byte) bool

+ func (pub *HybridPublicIdentity) X25519PublicKey() [x25519KeySize]byte

+ type PublicIdentity struct

+ func NewPublicIdentity(edPublicKey, xPublicKey []byte) (*PublicIdentity, error)

+ func UnmarshalPublicIdentity(data []byte) (*PublicIdentity, error)

+ func (pi *PublicIdentity) Destination() [endpoints.RNSDestinationLen]byte

+ func (pi *PublicIdentity) EncryptionPublicKey() []byte

+ func (pi *PublicIdentity) MarshalBinary() ([]byte, error)

+ func (pi *PublicIdentity) PublicKey() []byte

+ func (pi *PublicIdentity) Verify(message, signature []byte) bool

+ type RNSAnnouncer struct

+ func NewRNSAnnouncer(identity *RNSIdentity, config RNSAnnouncerConfig, loggers ...log.Logger) *RNSAnnouncer

+ func (a *RNSAnnouncer) AddEntry(entry *AnnounceEntry)

+ func (a *RNSAnnouncer) Announce() error

+ func (a *RNSAnnouncer) GetTable() map[[endpoints.RNSDestinationLen]byte]*AnnounceEntry

+ func (a *RNSAnnouncer) Lookup(dest [endpoints.RNSDestinationLen]byte) *Announce

+ func (a *RNSAnnouncer) LookupEntry(dest [endpoints.RNSDestinationLen]byte) (*AnnounceEntry, error)

+ func (a *RNSAnnouncer) ProcessAnnouncement(packet []byte, transportAddr netip.AddrPort) error

+ func (a *RNSAnnouncer) RegisterHandler(handler interface{})

+ func (a *RNSAnnouncer) Size() int

+ func (a *RNSAnnouncer) Start() error

+ type RNSAnnouncerConfig struct

+ AnnounceInterval time.Duration

+ GatewayAddr string

+ ListenAddr string

+ func DefaultRNSAnnouncerConfig() RNSAnnouncerConfig

+ type RNSConfig struct

+ AnnounceInterval time.Duration

+ ConfigPath string

+ Enabled bool

+ GatewayAddr string

+ IdentityPath string

+ Interfaces []string

+ LinkTimeout time.Duration

+ func DefaultRNSConfig() RNSConfig

+ type RNSIdentity struct

+ func LoadOrGenerateIdentity(path string) (*RNSIdentity, error)

+ func LoadRNSIdentity(path string) (*RNSIdentity, error)

+ func NewRNSIdentity() (*RNSIdentity, error)

+ func (id *RNSIdentity) Close() error

+ func (id *RNSIdentity) Decrypt(ephemeralPublicKey []byte) (sharedSecret []byte, err error)

+ func (id *RNSIdentity) Destination() [endpoints.RNSDestinationLen]byte

+ func (id *RNSIdentity) Encrypt(recipientXPublicKey []byte) (ephemeralPub []byte, sharedSecret []byte, err error)

+ func (id *RNSIdentity) EncryptionPublicKey() []byte

+ func (id *RNSIdentity) Hash() [endpoints.RNSDestinationLen]byte

+ func (id *RNSIdentity) PublicKey() []byte

+ func (id *RNSIdentity) Save(path string) error

+ func (id *RNSIdentity) Sign(message []byte) []byte

+ func (id *RNSIdentity) SigningPublicKey() []byte

+ func (id *RNSIdentity) Verify(message, signature []byte) bool

+ func (id *RNSIdentity) X25519Exchange(peerPublicKey [x25519KeySize]byte) ([x25519KeySize]byte, error)

+ func (id *RNSIdentity) X25519PublicKey() [x25519KeySize]byte

+ type RNSLink struct

+ func NewHybridRNSLink(conn net.Conn, identity *HybridIdentity) *RNSLink

+ func NewRNSLink(conn net.Conn, identity *RNSIdentity) *RNSLink

+ func (l *RNSLink) Close() error

+ func (l *RNSLink) Handshake(initiator bool, peerDestination [endpoints.RNSDestinationLen]byte) error

+ func (l *RNSLink) IsEstablished() bool

+ func (l *RNSLink) IsHybrid() bool

+ func (l *RNSLink) LocalAddr() net.Addr

+ func (l *RNSLink) PeerDestination() [endpoints.RNSDestinationLen]byte

+ func (l *RNSLink) PeerIdentity() *HybridPublicIdentity

+ func (l *RNSLink) Read(b []byte) (int, error)

+ func (l *RNSLink) RemoteAddr() net.Addr

+ func (l *RNSLink) SetDeadline(t time.Time) error

+ func (l *RNSLink) SetReadDeadline(t time.Time) error

+ func (l *RNSLink) SetWriteDeadline(t time.Time) error

+ func (l *RNSLink) Write(b []byte) (int, error)

+ type RNSTransport interface

+ Available func() bool

+ Close func() error

+ Dial func(ctx context.Context, destination [endpoints.RNSDestinationLen]byte) (net.Conn, error)

+ func NewRNSTransport(config RNSConfig, logger log.Logger) RNSTransport

+ type ZWingDialer struct

+ func NewZWingDialer(base EndpointDialer, cfg ZWingDialerConfig, logger log.Logger) (*ZWingDialer, error)

+ func (z *ZWingDialer) Dial(ctx context.Context, ip netip.AddrPort, expectedRemote *zwing.IdentityPublic) (net.Conn, error)

+ func (z *ZWingDialer) DialEndpoint(ctx context.Context, endpoint endpoints.Endpoint, ...) (net.Conn, error)

+ func (z *ZWingDialer) Wrap(raw net.Conn, expectedRemote *zwing.IdentityPublic) (net.Conn, error)

+ type ZWingDialerConfig struct

+ HandshakeTimeout time.Duration

+ LocalIdentity *zwing.Identity

+ type ZWingListener struct

+ func NewZWingListener(raw net.Listener, cfg ZWingDialerConfig, logger log.Logger) (*ZWingListener, error)

+ func (l *ZWingListener) Accept() (net.Conn, error)

+ func (l *ZWingListener) Addr() net.Addr

+ func (l *ZWingListener) Close() error