conntrack

package module
v0.1.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Dec 12, 2018 License: MIT Imports: 9 Imported by: 19

README

go-conntrack Build Status GoDoc

This is go-conntrack and it is written in golang. It provides a C-binding free API to the conntrack subsystem of the Linux kernel.

Example

package main
import (
    "fmt"

    ct "github.com/florianl/go-conntrack"
)

func main() {
    // Opens the socket for the communication with the subsystem
    nfct, err := ct.Open()
    if err != nil {
        fmt.Println("Could not open socket:", err)
        return
    }
    defer nfct.Close()

    // Get all IPv4 sessions
    sessions, err := nfct.Dump(ct.Ct, ct.CtIPv4)
    if err != nil {
        fmt.Println("Could not dump sessions:", err)
        return
    }

    for _, x := range sessions {
        oSrcIP, _ := x.OrigSrcIP()
        oDstIP, _ := x.OrigDstIP()
        // Print source and destination for each IPv4 session
        fmt.Printf("src: %s\tdst: %s \n", oSrcIP, oDstIP)
    }
}

For documentation and more examples please take a look at GoDoc

Documentation

Overview

Package conntrack provides an API to interact with the conntrack subsystem of the netfilter family from the linux kernel.

Example:

package main
import (
	"fmt"

	ct "github.com/florianl/go-conntrack"
)

func main() {
	// Opens the socket for the communication with the subsystem
	nfct, err := ct.Open()
	if err != nil {
		fmt.Println("Could not open socket:", err)
		return
	}
	defer nfct.Close()

	// Get all IPv4 sessions
	sessions, err := nfct.Dump(ct.Ct, ct.CtIPv4)
	if err != nil {
		fmt.Println("Could not dump sessions:", err)
		return
	}

	for _, x := range sessions {
		oSrcIP, _ := x.OrigSrcIP()
		oDstIP, _ := x.OrigDstIP()
		// Print source and destination for each IPv4 session
		fmt.Printf("src: %s\tdst: %s \n", oSrcIP, oDstIP)
	}
}

Index

Examples

Constants

View Source
const (
	CPUID                 = ConnAttrType(0)
	CPUStatsSearched      = ConnAttrType(1)  /* u64 bits */
	CPUStatsFound         = ConnAttrType(2)  /* u64 bits */
	CPUStatsNew           = ConnAttrType(3)  /* u64 bits */
	CPUStatsInvalid       = ConnAttrType(4)  /* u64 bits */
	CPUStatsIgnore        = ConnAttrType(5)  /* u64 bits */
	CPUStatsDelete        = ConnAttrType(6)  /* u64 bits */
	CPUStatsDeleteList    = ConnAttrType(7)  /* u64 bits */
	CPUStatsInsert        = ConnAttrType(8)  /* u64 bits */
	CPUStatsInsertFailed  = ConnAttrType(9)  /* u64 bits */
	CPUStatsDrop          = ConnAttrType(10) /* u64 bits */
	CPUStatsEarlyDrop     = ConnAttrType(11) /* u64 bits */
	CPUStatsError         = ConnAttrType(12) /* u64 bits */
	CPUStatsSearchRestart = ConnAttrType(13) /* u64 bits */
)

Various CPU related statistics based on libnetfilter_conntrack.h

View Source
const (
	StatsGlobalEntries    = 1
	StatsGlobalMaxEntries = 2
)

Various types of global statistics

Variables

View Source
var (
	ErrConnNoSrcIP = errors.New("Conn has no source IP")
	ErrConnNoDstIP = errors.New("Conn has no destination IP")
	ErrConnNoAttr  = errors.New("Conn has not this attribute")
)

Various errors which may occur when procressing a connection

View Source
var (
	ErrAttrLength         = errors.New("Incorrect length of attribute")
	ErrAttrNotImplemented = errors.New("Attribute not implemented")
	ErrAttrNotExist       = errors.New("Type of attribute does not exist")
	ErrDataLength         = errors.New("Incorrect length of provided data")
)

Various errors which may occur when processing attributes

View Source
var ErrNotLinux = errors.New("package requires the netfilter subsystem of the linux kernel")

ErrNotLinux is returned when using this package on a non linux OS

View Source
var ErrUnknownCtTable = errors.New("Not supported for this subsystem")

ErrUnknownCtTable will be return, if the function can not be performed on this subsystem

Functions

This section is empty.

Types

type Conn

type Conn map[ConnAttrType][]byte

Conn contains all the information of a connection

func ParseAttributes

func ParseAttributes(data []byte) (Conn, error)

ParseAttributes extracts all the attributes from the given data

func (Conn) OrigDstIP

func (c Conn) OrigDstIP() (net.IP, error)

OrigDstIP returns the net.IP representation of the destination IP

func (Conn) OrigSrcIP

func (c Conn) OrigSrcIP() (net.IP, error)

OrigSrcIP returns the net.IP representation of the source IP

func (Conn) Uint8

func (c Conn) Uint8(attr ConnAttrType) (uint8, error)

Uint8 returns the uint8 representation of the given attribute's data.

func (Conn) Uint16

func (c Conn) Uint16(attr ConnAttrType) (uint16, error)

Uint16 returns the uint16 representation of the given attribute's data.

func (Conn) Uint32

func (c Conn) Uint32(attr ConnAttrType) (uint32, error)

Uint32 returns the uint32 representation of the given attribute's data.

func (Conn) Uint64

func (c Conn) Uint64(attr ConnAttrType) (uint64, error)

Uint64 returns the uint64 representation of the given attribute's data.

type ConnAttr

type ConnAttr struct {
	Type ConnAttrType
	Data []byte
	// Mask is required for specific attributes, if you want to filter for them
	Mask []byte
	// Negates this attribute for filtering
	Negate bool
}

ConnAttr represents the type and value of a attribute of a connection

type ConnAttrType

type ConnAttrType uint16

ConnAttrType specifies the attribute of a connection

const (
	AttrOrigIPv4Src             ConnAttrType = iota /* u32 bits, requires a mask if applied as filter */
	AttrOrigIPv4Dst             ConnAttrType = iota /* u32 bits, requires a mask if applied as filter */
	AttrReplIPv4Src             ConnAttrType = iota /* u32 bits, requires a mask if applied as filter */
	AttrReplIPv4Dst             ConnAttrType = iota /* u32 bits, requires a mask if applied as filter */
	AttrOrigIPv6Src             ConnAttrType = iota /* u128 bits */
	AttrOrigIPv6Dst             ConnAttrType = iota /* u128 bits */
	AttrReplIPv6Src             ConnAttrType = iota /* u128 bits */
	AttrReplIPv6Dst             ConnAttrType = iota /* u128 bits */
	AttrOrigPortSrc             ConnAttrType = iota /* u16 bits */
	AttrOrigPortDst             ConnAttrType = iota /* u16 bits */
	AttrReplPortSrc             ConnAttrType = iota /* u16 bits */
	AttrReplPortDst             ConnAttrType = iota /* u16 bits */
	AttrIcmpType                ConnAttrType = iota /* u8 bits */
	AttrIcmpCode                ConnAttrType = iota /* u8 bits */
	AttrIcmpID                  ConnAttrType = iota /* u16 bits */
	AttrOrigL3Proto             ConnAttrType = iota /* u8 bits */
	AttrReplL3Proto             ConnAttrType = iota /* u8 bits */
	AttrOrigL4Proto             ConnAttrType = iota /* u8 bits */
	AttrReplL4Proto             ConnAttrType = iota /* u8 bits */
	AttrTCPState                ConnAttrType = iota /* u8 bits */
	AttrSNatIPv4                ConnAttrType = iota /* u32 bits */
	AttrDNatIPv4                ConnAttrType = iota /* u32 bits */
	AttrSNatPort                ConnAttrType = iota /* u16 bits */
	AttrDNatPort                ConnAttrType = iota /* u16 bits */
	AttrTimeout                 ConnAttrType = iota /* u32 bits */
	AttrMark                    ConnAttrType = iota /* u32 bits, requires a mask if applied as filter */
	AttrOrigCounterPackets      ConnAttrType = iota /* u64 bits */
	AttrReplCounterPackets      ConnAttrType = iota /* u64 bits */
	AttrOrigCounterBytes        ConnAttrType = iota /* u64 bits */
	AttrReplCounterBytes        ConnAttrType = iota /* u64 bits */
	AttrUse                     ConnAttrType = iota /* u32 bits */
	AttrID                      ConnAttrType = iota /* u32 bits */
	AttrStatus                  ConnAttrType = iota /* u32 bits  */
	AttrTCPFlagsOrig            ConnAttrType = iota /* u8 bits */
	AttrTCPFlagsRepl            ConnAttrType = iota /* u8 bits */
	AttrTCPMaskOrig             ConnAttrType = iota /* u8 bits */
	AttrTCPMaskRepl             ConnAttrType = iota /* u8 bits */
	AttrMasterIPv4Src           ConnAttrType = iota /* u32 bits */
	AttrMasterIPv4Dst           ConnAttrType = iota /* u32 bits */
	AttrMasterIPv6Src           ConnAttrType = iota /* u128 bits */
	AttrMasterIPv6Dst           ConnAttrType = iota /* u128 bits */
	AttrMasterPortSrc           ConnAttrType = iota /* u16 bits */
	AttrMasterPortDst           ConnAttrType = iota /* u16 bits */
	AttrMasterL3Proto           ConnAttrType = iota /* u8 bits */
	AttrMasterL4Proto           ConnAttrType = iota /* u8 bits */
	AttrSecmark                 ConnAttrType = iota /* u32 bits */
	AttrOrigNatSeqCorrectionPos ConnAttrType = iota /* u32 bits */
	AttrOrigNatSeqOffsetBefore  ConnAttrType = iota /* u32 bits */
	AttrOrigNatSeqOffsetAfter   ConnAttrType = iota /* u32 bits */
	AttrReplNatSeqCorrectionPos ConnAttrType = iota /* u32 bits */
	AttrReplNatSeqOffsetBefore  ConnAttrType = iota /* u32 bits */
	AttrReplNatSeqOffsetAfter   ConnAttrType = iota /* u32 bits */
	AttrSctpState               ConnAttrType = iota /* u8 bits */
	AttrSctpVtagOrig            ConnAttrType = iota /* u32 bits */
	AttrSctpVtagRepl            ConnAttrType = iota /* u32 bits */
	AttrHelperName              ConnAttrType = iota /* string (30 bytes max) */
	AttrDccpState               ConnAttrType = iota /* u8 bits */
	AttrDccpRole                ConnAttrType = iota /* u8 bits */
	AttrDccpHandshakeSeq        ConnAttrType = iota /* u64 bits */
	AttrTCPWScaleOrig           ConnAttrType = iota /* u8 bits */
	AttrTCPWScaleRepl           ConnAttrType = iota /* u8 bits */
	AttrZone                    ConnAttrType = iota /* u16 bits */
	AttrSecCtx                  ConnAttrType = iota /* string */
	AttrTimestampStart          ConnAttrType = iota /* u64 bits linux >= 2.6.38 */
	AttrTimestampStop           ConnAttrType = iota /* u64 bits linux >= 2.6.38 */
	AttrHelperInfo              ConnAttrType = iota /* variable length */
	AttrConnlabels              ConnAttrType = iota /* variable length */
	AttrConnlabelsMask          ConnAttrType = iota /* variable length */
	AttrOrigzone                ConnAttrType = iota /* u16 bits */
	AttrReplzone                ConnAttrType = iota /* u16 bits */
	AttrSNatIPv6                ConnAttrType = iota /* u128 bits */
	AttrDNatIPv6                ConnAttrType = iota /* u128 bits */

	AttrExpID     ConnAttrType = iota /* u32 bits */
	AttrExpFlags  ConnAttrType = iota /* u32 bits */
	AttrExpClass  ConnAttrType = iota /* u32 bits */
	AttrExpNATDir ConnAttrType = iota /* u32 bits */

)

Attributes of a connection based on libnetfilter_conntrack.h

type CtFamily

type CtFamily uint8

CtFamily specifies the network family

const (
	CtIPv6 CtFamily = unix.AF_INET6
	CtIPv4 CtFamily = unix.AF_INET
)

Supported family types

type CtTable

type CtTable int

CtTable specifies the subsystem of conntrack

const (
	// Conntrack table
	Ct CtTable = 0
	// Conntrack expect table
	CtExpected CtTable = 0
)

Supported conntrack subsystems for Linux systems

type FilterAttr

type FilterAttr struct {
	Mark, MarkMask []byte
}

FilterAttr represents a very basic filter

type NetlinkGroup

type NetlinkGroup uint32

NetlinkGroup represents a Netlink multicast group

const (
	NetlinkCtNew             NetlinkGroup = 1 << iota
	NetlinkCtUpdate          NetlinkGroup = 1 << iota
	NetlinkCtDestroy         NetlinkGroup = 1 << iota
	NetlinkCtExpectedNew     NetlinkGroup = 1 << iota
	NetlinkCtExpectedUpdate  NetlinkGroup = 1 << iota
	NetlinkCtExpectedDestroy NetlinkGroup = 1 << iota
)

Supported Netlink groups

type Nfct

type Nfct struct {
	// Con is the pure representation of a netlink socket
	Con *netlink.Conn
}

Nfct represents a conntrack handler

func Open

func Open() (*Nfct, error)

Open returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

func (*Nfct) Close

func (nfct *Nfct) Close() error

Close returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

func (*Nfct) Create

func (nfct *Nfct) Create(_ CtTable, _ CtFamily, _ []ConnAttr) error

Create returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

Example
package main

import (
	"fmt"
	"net"

	ct "github.com/florianl/go-conntrack"
)

func main() {
	nfct, err := ct.Open()
	if err != nil {
		fmt.Println("Could not create nfct:", err)
		return
	}
	defer nfct.Close()
	ipA := net.ParseIP("1.1.1.1")
	ipB := net.ParseIP("8.8.8.8")
	err = nfct.Create(ct.Ct, ct.CtIPv4, []ct.ConnAttr{
		{Type: ct.AttrOrigIPv4Src, Data: []byte{ipA[12], ipA[13], ipA[14], ipA[15]}},
		{Type: ct.AttrOrigIPv4Dst, Data: []byte{ipB[12], ipB[13], ipB[14], ipB[15]}},
		{Type: ct.AttrReplIPv4Src, Data: []byte{ipB[12], ipB[13], ipB[14], ipB[15]}},
		{Type: ct.AttrReplIPv4Dst, Data: []byte{ipA[12], ipA[13], ipA[14], ipA[15]}},
		{Type: ct.AttrOrigL4Proto, Data: []byte{0x02}},
		{Type: ct.AttrReplL4Proto, Data: []byte{0x02}},
		{Type: ct.AttrStatus, Data: []byte{0x0, 0x0, 0x0, 0x08}},
		{Type: ct.AttrTimeout, Data: []byte{0x0, 0x0, 0x0, 0x42}}})
	if err != nil {
		fmt.Println("Could not create new session:", err)
		return
	}
}

func (*Nfct) Dump

func (nfct *Nfct) Dump(_ CtTable, _ CtFamily) ([]Conn, error)

Dump returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

Example
package main

import (
	"fmt"

	ct "github.com/florianl/go-conntrack"
)

func main() {
	nfct, err := ct.Open()
	if err != nil {
		fmt.Println("Could not create nfct:", err)
		return
	}
	defer nfct.Close()
	sessions, err := nfct.Dump(ct.Ct, ct.CtIPv4)
	if err != nil {
		fmt.Println("Could not dump sessions:", err)
		return
	}

	for _, x := range sessions {
		oSrcIP, _ := x.OrigSrcIP()
		oDstIP, _ := x.OrigDstIP()
		fmt.Printf("src: %s\tdst: %s \n", oSrcIP, oDstIP)
	}
}

func (*Nfct) Flush

func (nfct *Nfct) Flush(_ CtTable, _ CtFamily) error

Flush returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

Example
package main

import (
	"fmt"

	ct "github.com/florianl/go-conntrack"
)

func main() {
	nfct, err := ct.Open()
	if err != nil {
		fmt.Println("Could not create nfct:", err)
		return
	}
	defer nfct.Close()
	err = nfct.Flush(ct.Ct, ct.CtIPv4)
	if err != nil {
		fmt.Println("Could not flush conntrack subsystem:", err)
		return
	}
}

func (*Nfct) Query

func (nfct *Nfct) Query(_ CtTable, _ CtFamily, _ FilterAttr) ([]Conn, error)

Query returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

Example
package main

import (
	"fmt"

	ct "github.com/florianl/go-conntrack"
)

func main() {
	nfct, err := ct.Open()
	if err != nil {
		fmt.Println("Could not create nfct:", err)
		return
	}
	defer nfct.Close()
	sessions, err := nfct.Query(ct.Ct, ct.CtIPv6,
		ct.FilterAttr{Mark: []byte{0x00, 0x0, 0x00, 0x01},
			MarkMask: []byte{0x00, 0x0, 0x0, 0xFF}})
	if err != nil {
		fmt.Println("Could not query sessions:", err)
		return
	}
	for _, x := range sessions {
		oSrcIP, _ := x.OrigSrcIP()
		oDstIP, _ := x.OrigDstIP()
		fmt.Printf("src: %s\tdst: %s \n", oSrcIP, oDstIP)

	}
}

func (*Nfct) Register

func (nfct *Nfct) Register(_ context.Context, _ CtTable, _ NetlinkGroup, _ func(c Conn) int) (<-chan error, error)

Register returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

func (*Nfct) RegisterFiltered

func (nfct *Nfct) RegisterFiltered(_ context.Context, _ CtTable, _ NetlinkGroup, _ []ConnAttr, _ func(c Conn) int) (<-chan error, error)

RegisterFiltered returns an error, as this packages highly depends on the netfilter subsystem of the linux kernel

Example
package main

import (
	"context"
	"fmt"
	"time"

	ct "github.com/florianl/go-conntrack"
)

func main() {
	nfct, err := ct.Open()
	if err != nil {
		fmt.Println("Could not create nfct:", err)
		return
	}
	defer nfct.Close()
	errChan, err := nfct.RegisterFiltered(
		context.Background(), ct.Ct, ct.NetlinkCtUpdate,
		[]ct.ConnAttr{
			{Type: ct.AttrOrigL4Proto, Data: []byte{0x11}}, // TCP
			{Type: ct.AttrOrigL4Proto, Data: []byte{0x06}}, // UDP
		},
		func(c ct.Conn) int { fmt.Println(c); return 0 },
	)
	if err != nil {
		fmt.Println("Could not register with filter:", err)
		return
	}
	for {
		select {
		case errMsg := <-errChan:
			fmt.Println(errMsg)
		case <-time.After(10 * time.Second):
			break
		}
	}
}

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL