nebula

Oct 29, 2026

Changes in this version

+ var ErrUnsafeVPNOverlap = errors.New(...)

type Control

+ func (c *Control) Commands() *commands.Registry

+ func (c *Control) InfoHandler() http.Handler

type HostMap

+ func (hm *HostMap) QueryIndexCached(index uint32, cache map[uint32]*HostInfo) *HostInfo

type InterfaceConfig

+ CpuAffinity []int

+ PinThreads bool

type NetworkType

+ const NetworkTypeUnsafeVPNOverlap

type RemoteList

+ func (r *RemoteList) ResolveHostnames()

Aug 21, 2026

Changes in this version

+ const RehandshakeAfterMessages

+ const RejectAfterMessages

type ConnectionState

+ func (cs *ConnectionState) NextMessageCounter() (uint64, bool)

type MessageMetrics

+ func (m *MessageMetrics) TxExhausted(i int64)

Jul 23, 2026

Changes in this version

+ var ErrAlreadyStarted = errors.New("nebula is already started")

+ var ErrAlreadyStopped = errors.New("nebula cannot be restarted")

+ var ErrOutOfWindow = errors.New("out of window packet")

+ var ErrUnknownState = errors.New("nebula state is invalid")

type CertState

+ func (cs *CertState) DefaultVersion() cert.Version

+ func (cs *CertState) GetCredential(v cert.Version) *handshake.Credential

type ConnectionState

+ func (cs *ConnectionState) Decrypt(l *slog.Logger, messageCounter uint64, out []byte, packet []byte, nb []byte) ([]byte, error)

+ func (cs *ConnectionState) VerifyRelay(l *slog.Logger, messageCounter uint64, packet []byte, nb []byte) error

type Control

+ func (c *Control) State() RunState

+ func (c *Control) Wait() error

type Firewall

+ InboundSendReject bool

+ OutboundSendReject bool

type HostInfo

+ func (i *HostInfo) GetRemote() netip.AddrPort

type InterfaceConfig

+ DnsServer *dnsServer

type LightHouse

+ func (lh *LightHouse) TriggerUpdate()

type MessageMetrics

+ func (m *MessageMetrics) RxInvalid(i int64)

type Punchy

+ func (p *Punchy) Schedule(target netip.AddrPort, vpnAddr netip.Addr)

+ func (p *Punchy) ScheduleRespond(vpnAddr netip.Addr)

+ func (p *Punchy) SendPunch(hostinfo *HostInfo)

+ func (p *Punchy) SendPunchToAll(hostinfo *HostInfo)

+ func (p *Punchy) Start(ctx context.Context, ifce EncWriter, hm *HostMap, lh lighthouseChecker)

type RemoteList

+ func (r *RemoteList) ClearHostnameResults()

+ func (r *RemoteList) ResetForOwner(ownerVpnAddr netip.Addr)

+ type RunState int

+ const StateReady

+ const StateStarted

+ const StateStopped

+ const StateStopping

+ const StateUnknown

+ type Scheduler struct

+ func NewScheduler[T any](queueSize int) *Scheduler[T]

+ func (s *Scheduler[T]) Run(ctx context.Context, fn func(T))

+ func (s *Scheduler[T]) Schedule(ctx context.Context, item T, delay time.Duration)

Jan 21, 2026 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Jan 16, 2026 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Dec 4, 2025 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Changes in this version

+ var ErrBadDetailsVpnAddr = errors.New("invalid packet, malformed detailsVpnAddr")

+ var ErrIPv4InvalidHeaderLength = errors.New("invalid ipv4 header length")

+ var ErrIPv4PacketTooShort = errors.New("ipv4 packet is too short")

+ var ErrIPv6CouldNotFindPayload = errors.New("could not find payload in ipv6 packet")

+ var ErrIPv6PacketTooShort = errors.New("ipv6 packet is too short")

+ var ErrPacketTooShort = errors.New("packet is too short")

+ var ErrPeerRejected = errors.New("remote address is not within a network that we handle")

+ var ErrUnknownIPVersion = errors.New("packet is an unknown ip version")

+ var ErrUnknownNetworkType = errors.New("unknown network type")

+ type Addr struct

+ Hi uint64

+ Lo uint64

+ func (*Addr) Descriptor() ([]byte, []int)

+ func (*Addr) ProtoMessage()

+ func (m *Addr) GetHi() uint64

+ func (m *Addr) GetLo() uint64

+ func (m *Addr) Marshal() (dAtA []byte, err error)

+ func (m *Addr) MarshalTo(dAtA []byte) (int, error)

+ func (m *Addr) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *Addr) Reset()

+ func (m *Addr) Size() (n int)

+ func (m *Addr) String() string

+ func (m *Addr) Unmarshal(dAtA []byte) error

+ func (m *Addr) XXX_DiscardUnknown()

+ func (m *Addr) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Addr) XXX_Merge(src proto.Message)

+ func (m *Addr) XXX_Size() int

+ func (m *Addr) XXX_Unmarshal(b []byte) error

type CertState

+ func (cs *CertState) GetDefaultCertificate() cert.Certificate

+ func (cs *CertState) MarshalJSON() ([]byte, error)

+ func (cs *CertState) String() string

type ConnectionState

+ func (cs *ConnectionState) Curve() cert.Curve

type Control

+ func (c *Control) GetHostInfoByVpnAddr(vpnAddr netip.Addr, pending bool) *ControlHostInfo

type ControlHostInfo

+ VpnAddrs []netip.Addr

type EncWriter

+ GetCertState func() *CertState

+ GetHostInfo func(vpnAddr netip.Addr) *HostInfo

+ SendMessageToVpnAddr func(t header.MessageType, st header.MessageSubType, vpnAddr netip.Addr, ...)

type HandshakeManager

+ func (hm *HandshakeManager) ForEachVpnAddr(f controlEach)

+ func (hm *HandshakeManager) QueryVpnAddr(vpnIp netip.Addr) *HostInfo

type HostMap

+ func (hm *HostMap) ForEachVpnAddr(f controlEach)

+ func (hm *HostMap) QueryVpnAddr(vpnIp netip.Addr) *HostInfo

+ func (hm *HostMap) QueryVpnAddrsRelayFor(targetIps []netip.Addr, relayHostIp netip.Addr) (*HostInfo, *Relay, error)

type Interface

+ func (f *Interface) GetCertState() *CertState

+ func (f *Interface) GetHostInfo(vpnIp netip.Addr) *HostInfo

+ func (f *Interface) SendMessageToVpnAddr(t header.MessageType, st header.MessageSubType, vpnAddr netip.Addr, ...)

type LightHouse

+ func (lh *LightHouse) DeleteVpnAddrs(allVpnAddrs []netip.Addr)

+ func (lh *LightHouse) IsAnyLighthouseAddr(vpnAddrs []netip.Addr) bool

+ func (lh *LightHouse) IsLighthouseAddr(vpnAddr netip.Addr) bool

type NebulaControl

+ OldRelayFromAddr uint32

+ OldRelayToAddr uint32

+ RelayFromAddr *Addr

+ RelayToAddr *Addr

+ func (m *NebulaControl) GetOldRelayFromAddr() uint32

+ func (m *NebulaControl) GetOldRelayToAddr() uint32

+ func (m *NebulaControl) GetRelayFromAddr() *Addr

+ func (m *NebulaControl) GetRelayToAddr() *Addr

type NebulaHandshakeDetails

+ CertVersion uint32

+ func (m *NebulaHandshakeDetails) GetCertVersion() uint32

type NebulaMetaDetails

+ OldRelayVpnAddrs []uint32

+ OldVpnAddr uint32

+ RelayVpnAddrs []*Addr

+ V4AddrPorts []*V4AddrPort

+ V6AddrPorts []*V6AddrPort

+ VpnAddr *Addr

+ func (d *NebulaMetaDetails) GetRelays() []netip.Addr

+ func (d *NebulaMetaDetails) GetVpnAddrAndVersion() (netip.Addr, cert.Version, error)

+ func (m *NebulaMetaDetails) GetOldRelayVpnAddrs() []uint32

+ func (m *NebulaMetaDetails) GetOldVpnAddr() uint32

+ func (m *NebulaMetaDetails) GetRelayVpnAddrs() []*Addr

+ func (m *NebulaMetaDetails) GetV4AddrPorts() []*V4AddrPort

+ func (m *NebulaMetaDetails) GetV6AddrPorts() []*V6AddrPort

+ func (m *NebulaMetaDetails) GetVpnAddr() *Addr

+ type NetworkType uint8

+ const NetworkTypeUnknown

+ const NetworkTypeUnsafe

+ const NetworkTypeVPN

+ const NetworkTypeVPNPeer

type Relay

+ PeerAddr netip.Addr

type RelayState

+ func (rs *RelayState) GetRelayForByAddr(addr netip.Addr) (*Relay, bool)

type RemoteAllowList

+ func (al *RemoteAllowList) AllowAll(vpnAddrs []netip.Addr, udpAddr netip.Addr) bool

+ func (al *RemoteAllowList) AllowUnknownVpnAddr(vpnAddr netip.Addr) bool

type RemoteList

+ func (r *RemoteList) RefreshFromHandshake(vpnAddrs []netip.Addr)

+ type V4AddrPort struct

+ Addr uint32

+ Port uint32

+ func (*V4AddrPort) Descriptor() ([]byte, []int)

+ func (*V4AddrPort) ProtoMessage()

+ func (m *V4AddrPort) GetAddr() uint32

+ func (m *V4AddrPort) GetPort() uint32

+ func (m *V4AddrPort) Marshal() (dAtA []byte, err error)

+ func (m *V4AddrPort) MarshalTo(dAtA []byte) (int, error)

+ func (m *V4AddrPort) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *V4AddrPort) Reset()

+ func (m *V4AddrPort) Size() (n int)

+ func (m *V4AddrPort) String() string

+ func (m *V4AddrPort) Unmarshal(dAtA []byte) error

+ func (m *V4AddrPort) XXX_DiscardUnknown()

+ func (m *V4AddrPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *V4AddrPort) XXX_Merge(src proto.Message)

+ func (m *V4AddrPort) XXX_Size() int

+ func (m *V4AddrPort) XXX_Unmarshal(b []byte) error

+ type V6AddrPort struct

+ Hi uint64

+ Lo uint64

+ Port uint32

+ func (*V6AddrPort) Descriptor() ([]byte, []int)

+ func (*V6AddrPort) ProtoMessage()

+ func (m *V6AddrPort) GetHi() uint64

+ func (m *V6AddrPort) GetLo() uint64

+ func (m *V6AddrPort) GetPort() uint32

+ func (m *V6AddrPort) Marshal() (dAtA []byte, err error)

+ func (m *V6AddrPort) MarshalTo(dAtA []byte) (int, error)

+ func (m *V6AddrPort) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *V6AddrPort) Reset()

+ func (m *V6AddrPort) Size() (n int)

+ func (m *V6AddrPort) String() string

+ func (m *V6AddrPort) Unmarshal(dAtA []byte) error

+ func (m *V6AddrPort) XXX_DiscardUnknown()

+ func (m *V6AddrPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *V6AddrPort) XXX_Merge(src proto.Message)

+ func (m *V6AddrPort) XXX_Size() int

+ func (m *V6AddrPort) XXX_Unmarshal(b []byte) error

type ViaSender

+ IsRelayed bool

+ UdpAddr netip.AddrPort

+ func (v ViaSender) MarshalJSON() ([]byte, error)

+ func (v ViaSender) String() string

Oct 10, 2025 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Jul 18, 2025 GO-2025-4068 +1 more

  GO-2025-4068: Slack Nebula may accept arbitrary source IP addresses in github.com/slackhq/nebula

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Dec 6, 2024 GO-2025-4068 +1 more

  GO-2025-4068: Slack Nebula may accept arbitrary source IP addresses in github.com/slackhq/nebula

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Changes in this version

+ const Disestablished

type RelayState

+ func (rs *RelayState) UpdateRelayForByIdxState(idx uint32, state int)

+ func (rs *RelayState) UpdateRelayForByIpState(vpnIp netip.Addr, state int)

Sep 9, 2024 GO-2025-4068 +1 more

  GO-2025-4068: Slack Nebula may accept arbitrary source IP addresses in github.com/slackhq/nebula

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Changes in this version

+ func AddrPortFromIp4AndPort(ip *Ip4AndPort) netip.AddrPort

+ func AddrPortFromIp6AndPort(ip *Ip6AndPort) netip.AddrPort

type Control

+ func (c *Control) CreateTunnel(vpnIp netip.Addr)

+ func (c *Control) GetCertByVpnIp(vpnIp netip.Addr) *cert.NebulaCertificate

+ func (c *Control) PrintTunnel(vpnIp netip.Addr) *ControlHostInfo

+ func (c *Control) QueryLighthouse(vpnIp netip.Addr) *CacheMap

Jun 6, 2024 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Jun 3, 2024 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

May 29, 2024 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

May 8, 2024 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Changes in this version

type HostMap

+ func NewHostMapFromConfig(l *logrus.Logger, vpnCIDR *net.IPNet, c *config.C) *HostMap

Jan 8, 2024 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Dec 19, 2023 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Dec 6, 2023 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Changes in this version

type CertState

+ Certificate *cert.NebulaCertificate

+ PrivateKey []byte

+ PublicKey []byte

+ RawCertificate []byte

+ RawCertificateNoKey []byte

type ConnectionState

+ func NewConnectionState(l *logrus.Logger, cipher string, certState *CertState, initiator bool, ...) *ConnectionState

type Control

+ func (c *Control) Context() context.Context

+ func (c *Control) Device() overlay.Device

type Firewall

+ func (f *Firewall) GetRuleHashFNV() uint32

+ func (f *Firewall) GetRuleHashes() string

+ type HandshakeHostInfo struct

type HandshakeManager

+ func (c *HandshakeManager) ForEachIndex(f controlEach)

+ func (c *HandshakeManager) ForEachVpnIp(f controlEach)

+ func (c *HandshakeManager) GetPreferredRanges() []*net.IPNet

+ func (hm *HandshakeManager) GetOrHandshake(vpnIp iputil.VpnIp, cacheCb func(*HandshakeHostInfo)) (*HostInfo, bool)

+ func (hm *HandshakeManager) HandleIncoming(addr *udp.Addr, via *ViaSender, packet []byte, h *header.H)

+ func (hm *HandshakeManager) QueryVpnIp(vpnIp iputil.VpnIp) *HostInfo

+ func (hm *HandshakeManager) StartHandshake(vpnIp iputil.VpnIp, cacheCb func(*HandshakeHostInfo)) *HostInfo

type HostMap

+ func (hm *HostMap) ForEachIndex(f controlEach)

+ func (hm *HostMap) ForEachVpnIp(f controlEach)

+ func (hm *HostMap) GetPreferredRanges() []*net.IPNet

type LightHouse

+ func (lh *LightHouse) StartUpdateWorker()

+ type PKI struct

+ func NewPKIFromConfig(l *logrus.Logger, c *config.C) (*PKI, error)

+ func (p *PKI) GetCAPool() *cert.NebulaCAPool

+ func (p *PKI) GetCertState() *CertState

Jun 1, 2023 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

May 18, 2023 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

May 17, 2023 GO-2026-4458

  GO-2026-4458: Blocklist Bypass possible via ECDSA Signature Malleability in github.com/slackhq/nebula

Changes in this version

+ const MaxHostInfosPerVpnIp

+ const PeerRequested

+ func NewCalculatedRemotesFromConfig(c *config.C, k string) (*cidr.Tree4, error)

+ func NewHostnameResults(ctx context.Context, l *logrus.Logger, d time.Duration, network string, ...) (*hostnamesResults, error)

type Control

+ func (c *Control) ListHostmapHosts(pendingMap bool) []ControlHostInfo

+ func (c *Control) ListHostmapIndexes(pendingMap bool) []ControlHostInfo

type EncWriter

+ Handshake func(vpnIp iputil.VpnIp)

+ SendMessageToHostInfo func(t header.MessageType, st header.MessageSubType, hostinfo *HostInfo, ...)

+ SendVia func(via *HostInfo, relay *Relay, ad, nb, out []byte, nocopy bool)

type Firewall

+ InSendReject bool

+ OutSendReject bool

type FirewallRule

+ LocalCIDR *cidr.Tree4

type HostInfo

+ HandshakeLastRemotes []*udp.Addr

type HostMap

+ func (hm *HostMap) MakePrimary(hostinfo *HostInfo)

+ func (hm *HostMap) QueryIndexIsPrimary(index uint32) (*HostInfo, bool, error)

+ func (hm *HostMap) QueryVpnIpRelayFor(targetIp, relayHostIp iputil.VpnIp) (*HostInfo, *Relay, error)

type Interface

+ func (f *Interface) SendMessageToHostInfo(t header.MessageType, st header.MessageSubType, hi *HostInfo, ...)

type Ip4AndPort

+ func NewIp4AndPortFromNetIP(ip netip.Addr, port uint16) *Ip4AndPort

type Ip6AndPort

+ func NewIp6AndPortFromNetIP(ip netip.Addr, port uint16) *Ip6AndPort

+ type LockingTimerWheel struct

+ func NewLockingTimerWheel(min, max time.Duration) *LockingTimerWheel[T]

+ func (lw *LockingTimerWheel[T]) Add(v T, timeout time.Duration) *TimeoutItem[T]

+ func (lw *LockingTimerWheel[T]) Advance(now time.Time)

+ func (lw *LockingTimerWheel[T]) Purge() (T, bool)

type NebulaMeta_MessageType

+ const NebulaMeta_HostUpdateNotificationAck

type Punchy

+ func (p *Punchy) GetRespondDelay() time.Duration

+ func (p *Punchy) GetTargetEverything() bool

type RelayState

+ func (rs *RelayState) CompleteRelayByIP(vpnIp iputil.VpnIp, remoteIdx uint32) bool

+ func (rs *RelayState) CompleteRelayByIdx(localIdx uint32, remoteIdx uint32) (*Relay, bool)

+ func (rs *RelayState) CopyAllRelayFor() []*Relay

type TimeoutItem

+ Item T

type TimerWheel

+ func (tw *TimerWheel[T]) Advance(now time.Time)

Jun 30, 2022

Changes in this version

+ const DefaultUseRelays

+ const Established

+ const ForwardingType

+ const Requested

+ const TerminalType

+ const Unknowntype

+ var NebulaControl_MessageType_name = map[int32]string

+ var NebulaControl_MessageType_value = map[string]int32

+ func AddRelay(l *logrus.Logger, relayHostInfo *HostInfo, hm *HostMap, vpnIp iputil.VpnIp, ...) (uint32, error)

+ func NewRelayManager(ctx context.Context, l *logrus.Logger, hostmap *HostMap, c *config.C) *relayManager

type Cache

+ Relay []*net.IP

type ControlHostInfo

+ CurrentRelaysThroughMe []iputil.VpnIp

+ CurrentRelaysToMe []iputil.VpnIp

type HostMap

+ Relays map[uint32]*HostInfo

+ func (hm *HostMap) DeleteRelayIdx(localIdx uint32)

+ func (hm *HostMap) QueryRelayIndex(index uint32) (*HostInfo, error)

+ func (hm *HostMap) RemoveRelay(localIdx uint32)

type Interface

+ func (f *Interface) Handshake(vpnIp iputil.VpnIp)

+ func (f *Interface) SendVia(viaIfc interface{}, relayIfc interface{}, ad, nb, out []byte, nocopy bool)

type LightHouse

+ func NewLightHouseFromConfig(l *logrus.Logger, c *config.C, myVpnNet *net.IPNet, pc *udp.Conn, p *Punchy) (*LightHouse, error)

+ func (lh *LightHouse) GetAdvertiseAddrs() []netIpAndPort

+ func (lh *LightHouse) GetLighthouses() map[iputil.VpnIp]struct{}

+ func (lh *LightHouse) GetLocalAllowList() *LocalAllowList

+ func (lh *LightHouse) GetRelaysForMe() []iputil.VpnIp

+ func (lh *LightHouse) GetRemoteAllowList() *RemoteAllowList

+ func (lh *LightHouse) GetStaticHostList() map[iputil.VpnIp]struct{}

+ func (lh *LightHouse) GetUpdateInterval() int64

type NebulaCipherState

+ func (s *NebulaCipherState) Overhead() int

+ type NebulaControl struct

+ InitiatorRelayIndex uint32

+ RelayFromIp uint32

+ RelayToIp uint32

+ ResponderRelayIndex uint32

+ Type NebulaControl_MessageType

+ func (*NebulaControl) Descriptor() ([]byte, []int)

+ func (*NebulaControl) ProtoMessage()

+ func (m *NebulaControl) GetInitiatorRelayIndex() uint32

+ func (m *NebulaControl) GetRelayFromIp() uint32

+ func (m *NebulaControl) GetRelayToIp() uint32

+ func (m *NebulaControl) GetResponderRelayIndex() uint32

+ func (m *NebulaControl) GetType() NebulaControl_MessageType

+ func (m *NebulaControl) Marshal() (dAtA []byte, err error)

+ func (m *NebulaControl) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaControl) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaControl) Reset()

+ func (m *NebulaControl) Size() (n int)

+ func (m *NebulaControl) String() string

+ func (m *NebulaControl) Unmarshal(dAtA []byte) error

+ func (m *NebulaControl) XXX_DiscardUnknown()

+ func (m *NebulaControl) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaControl) XXX_Merge(src proto.Message)

+ func (m *NebulaControl) XXX_Size() int

+ func (m *NebulaControl) XXX_Unmarshal(b []byte) error

+ type NebulaControl_MessageType int32

+ const NebulaControl_CreateRelayRequest

+ const NebulaControl_CreateRelayResponse

+ const NebulaControl_None

+ func (NebulaControl_MessageType) EnumDescriptor() ([]byte, []int)

+ func (x NebulaControl_MessageType) String() string

type NebulaMetaDetails

+ RelayVpnIp []uint32

+ func (m *NebulaMetaDetails) GetRelayVpnIp() []uint32

type Punchy

+ func (p *Punchy) GetDelay() time.Duration

+ func (p *Punchy) GetPunch() bool

+ func (p *Punchy) GetRespond() bool

+ type Relay struct

+ LocalIndex uint32

+ PeerIp iputil.VpnIp

+ RemoteIndex uint32

+ State int

+ Type int

+ type RelayState struct

+ func (rs *RelayState) CopyRelayForIdxs() []uint32

+ func (rs *RelayState) CopyRelayForIps() []iputil.VpnIp

+ func (rs *RelayState) CopyRelayIps() []iputil.VpnIp

+ func (rs *RelayState) DeleteRelay(ip iputil.VpnIp)

+ func (rs *RelayState) GetRelayForByIp(ip iputil.VpnIp) (*Relay, bool)

+ func (rs *RelayState) InsertRelay(ip iputil.VpnIp, idx uint32, r *Relay)

+ func (rs *RelayState) InsertRelayTo(ip iputil.VpnIp)

+ func (rs *RelayState) QueryRelayForByIdx(idx uint32) (*Relay, bool)

+ func (rs *RelayState) QueryRelayForByIp(vpnIp iputil.VpnIp) (*Relay, bool)

+ func (rs *RelayState) RemoveRelay(localIdx uint32) (iputil.VpnIp, bool)

+ type ViaSender struct

Nov 11, 2021

Changes in this version

type Control

+ func (c *Control) GetHostInfoByVpnIp(vpnIp iputil.VpnIp, pending bool) *ControlHostInfo

type ControlHostInfo

+ VpnIp net.IP

type HandshakeManager

+ func (c *HandshakeManager) AddVpnIp(vpnIp iputil.VpnIp, init func(*HostInfo)) *HostInfo

type HostInfo

+ func (i *HostInfo) SetRemoteIfPreferred(hm *HostMap, newRemote *udp.Addr) bool

type HostMap

+ func (hm *HostMap) AddVpnIp(vpnIp iputil.VpnIp, init func(hostinfo *HostInfo)) (hostinfo *HostInfo, created bool)

+ func (hm *HostMap) AddVpnIpHostInfo(vpnIp iputil.VpnIp, h *HostInfo)

+ func (hm *HostMap) DeleteVpnIp(vpnIp iputil.VpnIp)

+ func (hm *HostMap) GetIndexByVpnIp(vpnIp iputil.VpnIp) (uint32, error)

+ func (hm *HostMap) PromoteBestQueryVpnIp(vpnIp iputil.VpnIp, ifce *Interface) (*HostInfo, error)

+ func (hm *HostMap) QueryVpnIp(vpnIp iputil.VpnIp) (*HostInfo, error)

type Interface

+ func (f *Interface) Close() error

type LightHouse

+ func (lh *LightHouse) DeleteVpnIp(vpnIp iputil.VpnIp)

+ type LocalAllowList struct

+ AllowList *AllowList

+ func NewLocalAllowListFromConfig(c *config.C, k string) (*LocalAllowList, error)

+ func (al *LocalAllowList) Allow(ip net.IP) bool

+ func (al *LocalAllowList) AllowName(name string) bool

+ type RemoteAllowList struct

+ AllowList *AllowList

+ func NewRemoteAllowListFromConfig(c *config.C, k, rangesKey string) (*RemoteAllowList, error)

+ func (al *RemoteAllowList) Allow(vpnIp iputil.VpnIp, ip net.IP) bool

+ func (al *RemoteAllowList) AllowIpV4(vpnIp iputil.VpnIp, ip iputil.VpnIp) bool

+ func (al *RemoteAllowList) AllowIpV6(vpnIp iputil.VpnIp, hi, lo uint64) bool

+ func (al *RemoteAllowList) AllowUnknownVpnIp(ip net.IP) bool

type Tun — darwin/amd64

+ DefaultMTU int

+ TXQueueLen int

+ func (c *Tun) Close() error

+ func (t *Tun) Read(to []byte) (int, error)

+ func (t *Tun) Write(from []byte) (int, error)

+ type WinTun struct — windows/amd64

+ Cidr *net.IPNet

+ Device string

+ MTU int

+ UnsafeRoutes []route

+ func (c *WinTun) Activate() error

+ func (c *WinTun) CidrNet() *net.IPNet

+ func (c *WinTun) Close() error

+ func (c *WinTun) DeviceName() string

+ func (c *WinTun) NewMultiQueueReader() (io.ReadWriteCloser, error)

+ func (c *WinTun) Read(b []byte) (int, error)

+ func (c *WinTun) Write(b []byte) (int, error)

+ func (c *WinTun) WriteRaw(b []byte) error

+ type WindowsWaterTun struct — windows/amd64

+ Cidr *net.IPNet

+ Device string

+ MTU int

+ UnsafeRoutes []route

+ func (c *WindowsWaterTun) Activate() error

+ func (c *WindowsWaterTun) CidrNet() *net.IPNet

+ func (c *WindowsWaterTun) Close() error

+ func (c *WindowsWaterTun) DeviceName() string

+ func (c *WindowsWaterTun) WriteRaw(b []byte) error

+ func (t *WindowsWaterTun) NewMultiQueueReader() (io.ReadWriteCloser, error)

May 11, 2021

Changes in this version

+ const ReQueryEvery

+ const RoamingSuppressSeconds

+ var ErrAlreadySeen = errors.New("already seen")

+ var ErrExistingHandshake = errors.New("existing handshake")

+ var ErrExistingHostInfo = errors.New("existing hostinfo")

+ var ErrHostNotKnown = errors.New("host not known")

+ var ErrIntOverflowNebula = fmt.Errorf("proto: integer overflow")

+ var ErrInvalidLengthNebula = fmt.Errorf("proto: negative length found during unmarshaling")

+ var ErrLocalIndexCollision = errors.New("local index collision")

+ var ErrUnexpectedEndOfGroupNebula = fmt.Errorf("proto: unexpected end of group")

+ func NewUDPAddrFromLH4(ipp *Ip4AndPort) *udpAddr

+ func NewUDPAddrFromLH6(ipp *Ip6AndPort) *udpAddr

+ func NewUDPStatsEmitter(udpConns []*udpConn) func()

type AllowList

+ func (al *AllowList) AllowIpV4(ip uint32) bool

+ func (al *AllowList) AllowIpV6(hi, lo uint64) bool

+ type CIDR6Tree struct

+ func NewCIDR6Tree() *CIDR6Tree

+ func (tree *CIDR6Tree) AddCIDR(cidr *net.IPNet, val interface{})

+ func (tree *CIDR6Tree) MostSpecificContains(ip net.IP) (value interface{})

+ func (tree *CIDR6Tree) MostSpecificContainsIpV4(ip uint32) (value interface{})

+ func (tree *CIDR6Tree) MostSpecificContainsIpV6(hi, lo uint64) (value interface{})

+ type Cache struct

+ Learned []*udpAddr

+ Reported []*udpAddr

+ type CacheMap map[string]*Cache

+ type ConntrackCache map[FirewallPacket]struct

+ type ConntrackCacheTicker struct

+ func NewConntrackCacheTicker(d time.Duration) *ConntrackCacheTicker

+ func (c *ConntrackCacheTicker) Get(l *logrus.Logger) ConntrackCache

type Control

+ func (c *Control) CloseAllTunnels(excludeLighthouses bool) (closed int)

type HandshakeManager

+ func (c *HandshakeManager) CheckAndComplete(hostinfo *HostInfo, handshakePacket uint8, overwrite bool, f *Interface) (*HostInfo, error)

+ func (c *HandshakeManager) Complete(hostinfo *HostInfo, f *Interface)

+ func (c *HandshakeManager) DeleteHostInfo(hostinfo *HostInfo)

type HostMap

+ RemoteIndexes map[uint32]*HostInfo

+ func (hm *HostMap) DeleteHostInfo(hostinfo *HostInfo)

+ func (hm *HostMap) DeleteReverseIndex(index uint32)

type Inside

+ NewMultiQueueReader func() (io.ReadWriteCloser, error)

type InterfaceConfig

+ ConntrackCacheTimeout time.Duration

+ type Ip4AndPort struct

+ Ip uint32

+ Port uint32

+ func NewIp4AndPort(ip net.IP, port uint32) *Ip4AndPort

+ func (*Ip4AndPort) Descriptor() ([]byte, []int)

+ func (*Ip4AndPort) ProtoMessage()

+ func (m *Ip4AndPort) GetIp() uint32

+ func (m *Ip4AndPort) GetPort() uint32

+ func (m *Ip4AndPort) Marshal() (dAtA []byte, err error)

+ func (m *Ip4AndPort) MarshalTo(dAtA []byte) (int, error)

+ func (m *Ip4AndPort) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *Ip4AndPort) Reset()

+ func (m *Ip4AndPort) Size() (n int)

+ func (m *Ip4AndPort) String() string

+ func (m *Ip4AndPort) Unmarshal(dAtA []byte) error

+ func (m *Ip4AndPort) XXX_DiscardUnknown()

+ func (m *Ip4AndPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Ip4AndPort) XXX_Merge(src proto.Message)

+ func (m *Ip4AndPort) XXX_Size() int

+ func (m *Ip4AndPort) XXX_Unmarshal(b []byte) error

+ type Ip6AndPort struct

+ Hi uint64

+ Lo uint64

+ Port uint32

+ func NewIp6AndPort(ip net.IP, port uint32) *Ip6AndPort

+ func (*Ip6AndPort) Descriptor() ([]byte, []int)

+ func (*Ip6AndPort) ProtoMessage()

+ func (m *Ip6AndPort) GetHi() uint64

+ func (m *Ip6AndPort) GetLo() uint64

+ func (m *Ip6AndPort) GetPort() uint32

+ func (m *Ip6AndPort) Marshal() (dAtA []byte, err error)

+ func (m *Ip6AndPort) MarshalTo(dAtA []byte) (int, error)

+ func (m *Ip6AndPort) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *Ip6AndPort) Reset()

+ func (m *Ip6AndPort) Size() (n int)

+ func (m *Ip6AndPort) String() string

+ func (m *Ip6AndPort) Unmarshal(dAtA []byte) error

+ func (m *Ip6AndPort) XXX_DiscardUnknown()

+ func (m *Ip6AndPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *Ip6AndPort) XXX_Merge(src proto.Message)

+ func (m *Ip6AndPort) XXX_Size() int

+ func (m *Ip6AndPort) XXX_Unmarshal(b []byte) error

type LightHouse

+ func (lh *LightHouse) AddStaticRemote(vpnIp uint32, toAddr *udpAddr)

+ func (lh *LightHouse) NewRequestHandler() *LightHouseHandler

+ func (lh *LightHouse) SendUpdate(f EncWriter)

+ type LightHouseHandler struct

+ func (lhh *LightHouseHandler) HandleRequest(rAddr *udpAddr, vpnIp uint32, p []byte, w EncWriter)

type NebulaHandshake

+ func (m *NebulaHandshake) Marshal() (dAtA []byte, err error)

+ func (m *NebulaHandshake) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaHandshake) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaHandshake) Size() (n int)

+ func (m *NebulaHandshake) Unmarshal(dAtA []byte) error

type NebulaHandshakeDetails

+ func (m *NebulaHandshakeDetails) Marshal() (dAtA []byte, err error)

+ func (m *NebulaHandshakeDetails) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaHandshakeDetails) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaHandshakeDetails) Size() (n int)

+ func (m *NebulaHandshakeDetails) Unmarshal(dAtA []byte) error

type NebulaMeta

+ func (m *NebulaMeta) Marshal() (dAtA []byte, err error)

+ func (m *NebulaMeta) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaMeta) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaMeta) Size() (n int)

+ func (m *NebulaMeta) Unmarshal(dAtA []byte) error

type NebulaMetaDetails

+ Ip4AndPorts []*Ip4AndPort

+ Ip6AndPorts []*Ip6AndPort

+ func (m *NebulaMetaDetails) GetIp4AndPorts() []*Ip4AndPort

+ func (m *NebulaMetaDetails) GetIp6AndPorts() []*Ip6AndPort

+ func (m *NebulaMetaDetails) Marshal() (dAtA []byte, err error)

+ func (m *NebulaMetaDetails) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaMetaDetails) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaMetaDetails) Size() (n int)

+ func (m *NebulaMetaDetails) Unmarshal(dAtA []byte) error

type NebulaPing

+ func (m *NebulaPing) Marshal() (dAtA []byte, err error)

+ func (m *NebulaPing) MarshalTo(dAtA []byte) (int, error)

+ func (m *NebulaPing) MarshalToSizedBuffer(dAtA []byte) (int, error)

+ func (m *NebulaPing) Size() (n int)

+ func (m *NebulaPing) Unmarshal(dAtA []byte) error

+ type RemoteList struct

+ func NewRemoteList() *RemoteList

+ func (r *RemoteList) BlockRemote(bad *udpAddr)

+ func (r *RemoteList) CopyAddrs(preferredRanges []*net.IPNet) []*udpAddr

+ func (r *RemoteList) CopyBlockedRemotes() []*udpAddr

+ func (r *RemoteList) CopyCache() *CacheMap

+ func (r *RemoteList) ForEach(preferredRanges []*net.IPNet, forEach forEachFunc)

+ func (r *RemoteList) LearnRemote(ownerVpnIp uint32, addr *udpAddr)

+ func (r *RemoteList) Len(preferredRanges []*net.IPNet) int

+ func (r *RemoteList) Rebuild(preferredRanges []*net.IPNet)

+ func (r *RemoteList) ResetBlockedRemotes()

type Tun — darwin/amd64, windows/amd64

+ func (t *Tun) NewMultiQueueReader() (io.ReadWriteCloser, error)

type Tun — linux/amd64

+ func (c *Tun) NewMultiQueueReader() (io.ReadWriteCloser, error)

+ func (c *Tun) Write(b []byte) (int, error)

Sep 22, 2020

Changes in this version

+ const DefaultHandshakeTriggerBuffer

+ var ErrInvalidLocalIP = errors.New("local IP is not in list of handled local IPs")

+ var ErrInvalidRemoteIP = errors.New("remote IP is not in remote certificate subnets")

+ var ErrNoMatchingRule = errors.New("no matching rule in firewall table")

type Config

+ func (c *Config) LoadString(raw string) error

+ type ContextualError struct

+ Context string

+ Fields map[string]interface{}

+ RealError error

+ func NewContextualError(msg string, fields map[string]interface{}, realError error) ContextualError

+ func (ce *ContextualError) Log(lr *logrus.Logger)

+ func (ce ContextualError) Error() string

+ func (ce ContextualError) Unwrap() error

+ type Control struct

+ func (c *Control) CloseTunnel(vpnIP uint32, localOnly bool) bool

+ func (c *Control) GetHostInfoByVpnIP(vpnIP uint32, pending bool) *ControlHostInfo

+ func (c *Control) ListHostmap(pendingMap bool) []ControlHostInfo

+ func (c *Control) RebindUDPServer()

+ func (c *Control) SetRemoteForTunnel(vpnIP uint32, addr udpAddr) *ControlHostInfo

+ func (c *Control) ShutdownBlock()

+ func (c *Control) Start()

+ func (c *Control) Stop()

+ type ControlHostInfo struct

+ CachedPackets int

+ Cert *cert.NebulaCertificate

+ CurrentRemote udpAddr

+ LocalIndex uint32

+ MessageCounter uint64

+ RemoteAddrs []udpAddr

+ RemoteIndex uint32

+ VpnIP net.IP

type Firewall

+ Conntrack *FirewallConntrack

+ type FirewallConntrack struct

+ Conns map[FirewallPacket]*conn

+ TimerWheel *TimerWheel

+ type Inside interface

+ Activate func() error

+ CidrNet func() *net.IPNet

+ DeviceName func() string

+ WriteRaw func([]byte) error

type InterfaceConfig

+ MessageMetrics *MessageMetrics

+ type MessageMetrics struct

+ func (m *MessageMetrics) Rx(t NebulaMessageType, s NebulaMessageSubType, i int64)

+ func (m *MessageMetrics) Tx(t NebulaMessageType, s NebulaMessageSubType, i int64)

type Tun — darwin/amd64, linux/amd64, windows/amd64

+ func (c *Tun) CidrNet() *net.IPNet

+ func (c *Tun) DeviceName() string

Apr 8, 2020

Changes in this version

+ const DefaultHandshakeRetries

+ const DefaultHandshakeTryInterval

+ const DefaultHandshakeWaitRotation

+ type AllowList struct

+ func (al *AllowList) Allow(ip uint32) bool

+ func (al *AllowList) AllowName(name string) bool

+ type AllowListNameRule struct

+ Allow bool

+ Name *regexp.Regexp

type Config

+ func (c *Config) GetAllowList(k string, allowInterfaces bool) (*AllowList, error)

+ func (c *Config) IsSet(k string) bool

+ type HandshakeConfig struct

type LightHouse

+ func (lh *LightHouse) SetLocalAllowList(allowList *AllowList)

+ func (lh *LightHouse) SetRemoteAllowList(allowList *AllowList)

+ type Punchy struct

+ Delay time.Duration

+ Punch bool

+ Respond bool

+ func NewPunchyFromConfig(c *Config) *Punchy

type Tun — windows/amd64

+ UnsafeRoutes []route

Jan 17, 2020

Changes in this version

+ const DEFAULT_MTU

type CIDRTree

+ func (tree *CIDRTree) MostSpecificContains(ip uint32) (value interface{})

+ type FirewallCA struct

+ Any *FirewallRule

+ CANames map[string]*FirewallRule

+ CAShas map[string]*FirewallRule

type HostInfo

+ func (i *HostInfo) CreateRemoteCIDR(c *cert.NebulaCertificate)

type LightHouse

+ func (lh *LightHouse) ValidateLHStaticEntries() error

type Tun — darwin/amd64, linux/amd64

+ UnsafeRoutes []route

Nov 19, 2019

Changes in this version

+ const HandshakeRetries

+ const HandshakeTryInterval

+ const HandshakeWaitRotation

+ const HeaderLen

+ const MaxRemotes

+ const PromoteEvery

+ const ReplayWindow

+ const RoamingSupressSeconds

+ const Version

+ var NebulaMeta_MessageType_name = map[int32]string

+ var NebulaMeta_MessageType_value = map[string]int32

+ var NebulaPing_MessageType_name = map[int32]string

+ var NebulaPing_MessageType_value = map[string]int32

+ func AddFirewallRulesFromConfig(inbound bool, config *Config, fw FirewallInterface) error

+ func HandleIncomingHandshake(f *Interface, addr *udpAddr, packet []byte, h *Header, hostinfo *HostInfo)

+ func HandshakeBytesWithMAC(details *NebulaHandshakeDetails, key []byte) ([]byte, error)

+ func HeaderEncode(b []byte, v uint8, t uint8, st uint8, ri uint32, c uint64) []byte

+ func Main(configPath string, configTest bool, buildVersion string)

+ func NewIpAndPortsFromNetIps(ips []udpAddr) *[]*IpAndPort

+ func NewListenConfig(multi bool) net.ListenConfig — darwin/amd64, windows/amd64

+ func NewListener(ip string, port int, multi bool) (*udpConn, error)

+ func NewUDPAddr(ip uint32, port uint16) *udpAddr

+ func NewUDPAddrFromString(s string) *udpAddr

+ func PrivateIP(ip net.IP) bool

+ func RecombineCertAndValidate(h *noise.HandshakeState, rawCertBytes []byte) (*cert.NebulaCertificate, error)

+ func SubTypeName(t NebulaMessageType, s NebulaMessageSubType) string

+ func TypeName(t NebulaMessageType) string

+ type Bits struct

+ func NewBits(bits uint64) *Bits

+ func (b *Bits) Check(i uint64) bool

+ func (b *Bits) Update(i uint64) bool

+ type CIDRNode struct

+ type CIDRTree struct

+ func NewCIDRTree() *CIDRTree

+ func (tree *CIDRTree) AddCIDR(cidr *net.IPNet, val interface{})

+ func (tree *CIDRTree) Contains(ip uint32) (value interface{})

+ func (tree *CIDRTree) Match(ip uint32) (value interface{})

+ type CertState struct

+ func NewCertState(certificate *cert.NebulaCertificate, privateKey []byte) (*CertState, error)

+ func NewCertStateFromConfig(c *Config) (*CertState, error)

+ type Config struct

+ Settings map[interface{}]interface{}

+ func NewConfig() *Config

+ func (c *Config) CatchHUP()

+ func (c *Config) Get(k string) interface{}

+ func (c *Config) GetBool(k string, d bool) bool

+ func (c *Config) GetDuration(k string, d time.Duration) time.Duration

+ func (c *Config) GetInt(k string, d int) int

+ func (c *Config) GetMap(k string, d map[interface{}]interface{}) map[interface{}]interface{}

+ func (c *Config) GetString(k, d string) string

+ func (c *Config) GetStringSlice(k string, d []string) []string

+ func (c *Config) HasChanged(k string) bool

+ func (c *Config) Load(path string) error

+ func (c *Config) RegisterReloadCallback(f func(*Config))

+ func (c *Config) ReloadConfig()

+ type ConnectionState struct

+ H *noise.HandshakeState

+ func (cs *ConnectionState) MarshalJSON() ([]byte, error)

+ type EncWriter interface

+ SendMessageToAll func(t NebulaMessageType, st NebulaMessageSubType, vpnIp uint32, p, nb, out []byte)

+ SendMessageToVpnIp func(t NebulaMessageType, st NebulaMessageSubType, vpnIp uint32, p, nb, out []byte)

+ type Firewall struct

+ Conns map[FirewallPacket]*conn

+ DefaultTimeout time.Duration

+ InRules *FirewallTable

+ OutRules *FirewallTable

+ TCPTimeout time.Duration

+ TimerWheel *TimerWheel

+ UDPTimeout time.Duration

+ func NewFirewall(tcpTimeout, UDPTimeout, defaultTimeout time.Duration, ...) *Firewall

+ func NewFirewallFromConfig(nc *cert.NebulaCertificate, c *Config) (*Firewall, error)

+ func (f *Firewall) AddRule(incoming bool, proto uint8, startPort int32, endPort int32, groups []string, ...) error

+ func (f *Firewall) Destroy()

+ func (f *Firewall) Drop(packet []byte, fp FirewallPacket, incoming bool, c *cert.NebulaCertificate, ...) bool

+ func (f *Firewall) EmitStats()

+ func (f *Firewall) GetRuleHash() string

+ type FirewallInterface interface

+ AddRule func(incoming bool, proto uint8, startPort int32, endPort int32, groups []string, ...) error

+ type FirewallPacket struct

+ Fragment bool

+ LocalIP uint32

+ LocalPort uint16

+ Protocol uint8

+ RemoteIP uint32

+ RemotePort uint16

+ func (fp *FirewallPacket) Copy() *FirewallPacket

+ func (fp FirewallPacket) MarshalJSON() ([]byte, error)

+ type FirewallRule struct

+ Any bool

+ CANames map[string]struct{}

+ CAShas map[string]struct{}

+ CIDR *CIDRTree

+ Groups [][]string

+ Hosts map[string]struct{}

+ type FirewallTable struct

+ AnyProto firewallPort

+ ICMP firewallPort

+ TCP firewallPort

+ UDP firewallPort

+ type HandshakeManager struct

+ InboundHandshakeTimer *SystemTimerWheel

+ OutboundHandshakeTimer *SystemTimerWheel

+ func NewHandshakeManager(tunCidr *net.IPNet, preferredRanges []*net.IPNet, mainHostMap *HostMap, ...) *HandshakeManager

+ func (c *HandshakeManager) AddIndex(index uint32, ci *ConnectionState) (*HostInfo, error)

+ func (c *HandshakeManager) AddIndexHostInfo(index uint32, h *HostInfo)

+ func (c *HandshakeManager) AddVpnIP(vpnIP uint32) *HostInfo

+ func (c *HandshakeManager) DeleteIndex(index uint32)

+ func (c *HandshakeManager) DeleteVpnIP(vpnIP uint32)

+ func (c *HandshakeManager) EmitStats()

+ func (c *HandshakeManager) NextInboundHandshakeTimerTick(now time.Time)

+ func (c *HandshakeManager) NextOutboundHandshakeTimerTick(now time.Time, f EncWriter)

+ func (c *HandshakeManager) QueryIndex(index uint32) (*HostInfo, error)

+ func (c *HandshakeManager) Run(f EncWriter)

+ type Header struct

+ MessageCounter uint64

+ RemoteIndex uint32

+ Reserved uint16

+ Subtype NebulaMessageSubType

+ Type NebulaMessageType

+ Version uint8

+ func NewHeader(b []byte) (*Header, error)

+ func (h *Header) Encode(b []byte) ([]byte, error)

+ func (h *Header) MarshalJSON() ([]byte, error)

+ func (h *Header) Parse(b []byte) error

+ func (h *Header) String() string

+ func (h *Header) SubTypeName() string

+ func (h *Header) TypeName() string

+ type HostInfo struct

+ ConnectionState *ConnectionState

+ HandshakeComplete bool

+ HandshakeCounter int

+ HandshakePacket map[uint8][]byte

+ HandshakeReady bool

+ Remotes []*HostInfoDest

+ func (i *HostInfo) AddRemote(r udpAddr) *udpAddr

+ func (i *HostInfo) BindConnectionState(cs *ConnectionState)

+ func (i *HostInfo) ClearConnectionState()

+ func (i *HostInfo) ClearRemotes()

+ func (i *HostInfo) ForcePromoteBest(preferredRanges []*net.IPNet)

+ func (i *HostInfo) GetCert() *cert.NebulaCertificate

+ func (i *HostInfo) MarshalJSON() ([]byte, error)

+ func (i *HostInfo) RecvErrorExceeded() bool

+ func (i *HostInfo) RemoteUDPAddrs() []*udpAddr

+ func (i *HostInfo) SetRemote(remote udpAddr)

+ func (i *HostInfo) TryPromoteBest(preferredRanges []*net.IPNet, ifce *Interface)

+ type HostInfoDest struct

+ func NewHostInfoDest(addr *udpAddr) *HostInfoDest

+ func (hid *HostInfoDest) MarshalJSON() ([]byte, error)

+ type HostMap struct

+ Hosts map[uint32]*HostInfo

+ Indexes map[uint32]*HostInfo

+ func NewHostMap(name string, vpnCIDR *net.IPNet, preferredRanges []*net.IPNet) *HostMap

+ func (hm *HostMap) Add(ip uint32, hostinfo *HostInfo)

+ func (hm *HostMap) AddIndex(index uint32, ci *ConnectionState) (*HostInfo, error)

+ func (hm *HostMap) AddIndexHostInfo(index uint32, h *HostInfo)

+ func (hm *HostMap) AddRemote(vpnIp uint32, remote *udpAddr) *HostInfo

+ func (hm *HostMap) AddVpnIP(vpnIP uint32) *HostInfo

+ func (hm *HostMap) AddVpnIPHostInfo(vpnIP uint32, h *HostInfo)

+ func (hm *HostMap) CheckHandshakeCompleteIP(vpnIP uint32) bool

+ func (hm *HostMap) CheckHandshakeCompleteIndex(index uint32) bool

+ func (hm *HostMap) ClearRemotes(vpnIP uint32)

+ func (hm *HostMap) DeleteIndex(index uint32)

+ func (hm *HostMap) DeleteVpnIP(vpnIP uint32)

+ func (hm *HostMap) EmitStats(name string)

+ func (hm *HostMap) GetIndexByVpnIP(vpnIP uint32) (uint32, error)

+ func (hm *HostMap) GetVpnIPByIndex(index uint32) (uint32, error)

+ func (hm *HostMap) PromoteBestQueryVpnIP(vpnIp uint32, ifce *Interface) (*HostInfo, error)

+ func (hm *HostMap) PunchList() []*udpAddr

+ func (hm *HostMap) Punchy(conn *udpConn)

+ func (hm *HostMap) QueryIndex(index uint32) (*HostInfo, error)

+ func (hm *HostMap) QueryReverseIndex(index uint32) (*HostInfo, error)

+ func (hm *HostMap) QueryVpnIP(vpnIp uint32) (*HostInfo, error)

+ func (hm *HostMap) SetDefaultRoute(ip uint32)

+ type IntIp uint32

+ func (ip IntIp) MarshalJSON() ([]byte, error)

+ func (ip IntIp) String() string

+ type Interface struct

+ func NewInterface(c *InterfaceConfig) (*Interface, error)

+ func (f *Interface) RegisterConfigChangeCallbacks(c *Config)

+ func (f *Interface) Run(tunRoutines, udpRoutines int, buildVersion string)

+ func (f *Interface) SendMessageToAll(t NebulaMessageType, st NebulaMessageSubType, vpnIp uint32, p, nb, out []byte)

+ func (f *Interface) SendMessageToVpnIp(t NebulaMessageType, st NebulaMessageSubType, vpnIp uint32, p, nb, out []byte)

+ type InterfaceConfig struct

+ Cipher string

+ DropLocalBroadcast bool

+ DropMulticast bool

+ Firewall *Firewall

+ HandshakeManager *HandshakeManager

+ HostMap *HostMap

+ Inside *Tun

+ Outside *udpConn

+ ServeDns bool

+ UDPBatchSize int

+ type IpAndPort struct

+ Ip uint32

+ Port uint32

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func NewIpAndPortFromUDPAddr(addr udpAddr) *IpAndPort

+ func (*IpAndPort) Descriptor() ([]byte, []int)

+ func (*IpAndPort) ProtoMessage()

+ func (m *IpAndPort) GetIp() uint32

+ func (m *IpAndPort) GetPort() uint32

+ func (m *IpAndPort) Reset()

+ func (m *IpAndPort) String() string

+ func (m *IpAndPort) XXX_DiscardUnknown()

+ func (m *IpAndPort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *IpAndPort) XXX_Merge(src proto.Message)

+ func (m *IpAndPort) XXX_Size() int

+ func (m *IpAndPort) XXX_Unmarshal(b []byte) error

+ type LightHouse struct

+ func NewLightHouse(amLighthouse bool, myIp uint32, ips []string, interval int, nebulaPort int, ...) *LightHouse

+ func (lh *LightHouse) AddRemote(vpnIP uint32, toIp *udpAddr, static bool)

+ func (lh *LightHouse) AddRemoteAndReset(vpnIP uint32, toIp *udpAddr)

+ func (lh *LightHouse) DeleteVpnIP(vpnIP uint32)

+ func (lh *LightHouse) HandleRequest(rAddr *udpAddr, vpnIp uint32, p []byte, c *cert.NebulaCertificate, f EncWriter)

+ func (lh *LightHouse) IsLighthouseIP(vpnIP uint32) bool

+ func (lh *LightHouse) LhUpdateWorker(f EncWriter)

+ func (lh *LightHouse) Query(ip uint32, f EncWriter) ([]udpAddr, error)

+ func (lh *LightHouse) QueryCache(ip uint32) []udpAddr

+ func (lh *LightHouse) QueryServer(ip uint32, f EncWriter)

+ type NebulaCipherState struct

+ func NewNebulaCipherState(s *noise.CipherState) *NebulaCipherState

+ func (s *NebulaCipherState) DecryptDanger(out, ad, ciphertext []byte, n uint64, nb []byte) ([]byte, error)

+ func (s *NebulaCipherState) EncryptDanger(out, ad, plaintext []byte, n uint64, nb []byte) ([]byte, error)

+ type NebulaHandshake struct

+ Details *NebulaHandshakeDetails

+ Hmac []byte

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*NebulaHandshake) Descriptor() ([]byte, []int)

+ func (*NebulaHandshake) ProtoMessage()

+ func (hs *NebulaHandshake) CheckHandshakeMAC(keys [][]byte) bool

+ func (m *NebulaHandshake) GetDetails() *NebulaHandshakeDetails

+ func (m *NebulaHandshake) GetHmac() []byte

+ func (m *NebulaHandshake) Reset()

+ func (m *NebulaHandshake) String() string

+ func (m *NebulaHandshake) XXX_DiscardUnknown()

+ func (m *NebulaHandshake) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaHandshake) XXX_Merge(src proto.Message)

+ func (m *NebulaHandshake) XXX_Size() int

+ func (m *NebulaHandshake) XXX_Unmarshal(b []byte) error

+ type NebulaHandshakeDetails struct

+ Cert []byte

+ Cookie uint64

+ InitiatorIndex uint32

+ ResponderIndex uint32

+ Time uint64

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*NebulaHandshakeDetails) Descriptor() ([]byte, []int)

+ func (*NebulaHandshakeDetails) ProtoMessage()

+ func (m *NebulaHandshakeDetails) GetCert() []byte

+ func (m *NebulaHandshakeDetails) GetCookie() uint64

+ func (m *NebulaHandshakeDetails) GetInitiatorIndex() uint32

+ func (m *NebulaHandshakeDetails) GetResponderIndex() uint32

+ func (m *NebulaHandshakeDetails) GetTime() uint64

+ func (m *NebulaHandshakeDetails) Reset()

+ func (m *NebulaHandshakeDetails) String() string

+ func (m *NebulaHandshakeDetails) XXX_DiscardUnknown()

+ func (m *NebulaHandshakeDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaHandshakeDetails) XXX_Merge(src proto.Message)

+ func (m *NebulaHandshakeDetails) XXX_Size() int

+ func (m *NebulaHandshakeDetails) XXX_Unmarshal(b []byte) error

+ type NebulaMessageSubType uint8

+ type NebulaMessageType uint8

+ type NebulaMeta struct

+ Details *NebulaMetaDetails

+ Type NebulaMeta_MessageType

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func NewLhQueryByInt(VpnIp uint32) *NebulaMeta

+ func NewLhQueryByIpString(VpnIp string) *NebulaMeta

+ func NewLhWhoami() *NebulaMeta

+ func (*NebulaMeta) Descriptor() ([]byte, []int)

+ func (*NebulaMeta) ProtoMessage()

+ func (m *NebulaMeta) GetDetails() *NebulaMetaDetails

+ func (m *NebulaMeta) GetType() NebulaMeta_MessageType

+ func (m *NebulaMeta) Reset()

+ func (m *NebulaMeta) String() string

+ func (m *NebulaMeta) XXX_DiscardUnknown()

+ func (m *NebulaMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaMeta) XXX_Merge(src proto.Message)

+ func (m *NebulaMeta) XXX_Size() int

+ func (m *NebulaMeta) XXX_Unmarshal(b []byte) error

+ type NebulaMetaDetails struct

+ Counter uint32

+ IpAndPorts []*IpAndPort

+ VpnIp uint32

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*NebulaMetaDetails) Descriptor() ([]byte, []int)

+ func (*NebulaMetaDetails) ProtoMessage()

+ func (m *NebulaMetaDetails) GetCounter() uint32

+ func (m *NebulaMetaDetails) GetIpAndPorts() []*IpAndPort

+ func (m *NebulaMetaDetails) GetVpnIp() uint32

+ func (m *NebulaMetaDetails) Reset()

+ func (m *NebulaMetaDetails) String() string

+ func (m *NebulaMetaDetails) XXX_DiscardUnknown()

+ func (m *NebulaMetaDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaMetaDetails) XXX_Merge(src proto.Message)

+ func (m *NebulaMetaDetails) XXX_Size() int

+ func (m *NebulaMetaDetails) XXX_Unmarshal(b []byte) error

+ type NebulaMeta_MessageType int32

+ const NebulaMeta_HostMovedNotification

+ const NebulaMeta_HostPunchNotification

+ const NebulaMeta_HostQuery

+ const NebulaMeta_HostQueryReply

+ const NebulaMeta_HostUpdateNotification

+ const NebulaMeta_HostWhoami

+ const NebulaMeta_HostWhoamiReply

+ const NebulaMeta_None

+ const NebulaMeta_PathCheck

+ const NebulaMeta_PathCheckReply

+ func (NebulaMeta_MessageType) EnumDescriptor() ([]byte, []int)

+ func (x NebulaMeta_MessageType) String() string

+ type NebulaPing struct

+ Time uint64

+ Type NebulaPing_MessageType

+ XXX_NoUnkeyedLiteral struct{}

+ XXX_sizecache int32

+ XXX_unrecognized []byte

+ func (*NebulaPing) Descriptor() ([]byte, []int)

+ func (*NebulaPing) ProtoMessage()

+ func (m *NebulaPing) GetTime() uint64

+ func (m *NebulaPing) GetType() NebulaPing_MessageType

+ func (m *NebulaPing) Reset()

+ func (m *NebulaPing) String() string

+ func (m *NebulaPing) XXX_DiscardUnknown()

+ func (m *NebulaPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

+ func (m *NebulaPing) XXX_Merge(src proto.Message)

+ func (m *NebulaPing) XXX_Size() int

+ func (m *NebulaPing) XXX_Unmarshal(b []byte) error

+ type NebulaPing_MessageType int32

+ const NebulaPing_Ping

+ const NebulaPing_Reply

+ func (NebulaPing_MessageType) EnumDescriptor() ([]byte, []int)

+ func (x NebulaPing_MessageType) String() string

+ type Probe struct

+ Addr *net.UDPAddr

+ Counter int

+ type SystemTimeoutItem struct

+ Item uint32

+ Next *SystemTimeoutItem

+ type SystemTimeoutList struct

+ Head *SystemTimeoutItem

+ Tail *SystemTimeoutItem

+ type SystemTimerWheel struct

+ func NewSystemTimerWheel(min, max time.Duration) *SystemTimerWheel

+ func (tw *SystemTimerWheel) Add(v uint32, timeout time.Duration) *SystemTimeoutItem

+ func (tw *SystemTimerWheel) Purge() interface{}

+ type TimeoutItem struct

+ Next *TimeoutItem

+ Packet FirewallPacket

+ type TimeoutList struct

+ Head *TimeoutItem

+ Tail *TimeoutItem

+ type TimerWheel struct

+ func NewTimerWheel(min, max time.Duration) *TimerWheel

+ func (tw *TimerWheel) Add(v FirewallPacket, timeout time.Duration) *TimeoutItem

+ func (tw *TimerWheel) Purge() (FirewallPacket, bool)

+ type Tun struct — darwin/amd64, linux/amd64, windows/amd64

+ Cidr *net.IPNet

+ DefaultMTU int

+ Device string

+ MTU int

+ MaxMTU int

+ Routes []route

+ TXQueueLen int

+ func (c *Tun) Activate() error

+ func (c *Tun) WriteRaw(b []byte) error

+ func (c Tun) Activate() error