packets

package
v0.0.1 Latest Latest
Warning

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

 Go to latest Published: Oct 31, 2025 License: BSD-3-Clause Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const ConnectionRejectedPacketType = PacketType(1)
View Source 
const FinalProofPacketType = PacketType(4)
View Source 
const HeaderSize = 1 + 16 + 8
View Source 
const HeaderSizeForFragmentation = HeaderSize + 1 + 1 + 2
View Source 
const InitPacketType = PacketType(2)
View Source 
const InitProofPacketType = PacketType(3)
View Source 
const PublicKeyDataPacketType = PacketType(6)
View Source 
const PublicKeyRequestPacketType = PacketType(5)
View Source 
const PublicKeySignedPacketType = PacketType(8)
View Source 
const SignaturePublicKeyRequestPacketType = PacketType(9)
View Source 
const SignatureRequestPacketType = PacketType(7)
View Source 
const SignedPacketPublicKeyPacketType = PacketType(10)

Variables

View Source 
var ErrFragmentIndexOutOfRange = errors.New("fragment index out of range")
View Source 
var ErrFragmentReceived = errors.New("fragment received")
View Source 
var ErrInvalidPacketID = errors.New("invalid packet id")
View Source 
var ErrMTUTooSmall = errors.New("MTU too small")
View Source 
var ErrNoEncapsulation = errors.New("no encapsulation")

ErrNoEncapsulation for no encapsulation data (Protocol 2A)

View Source 
var ErrNoPacketToFlush = errors.New("no packet to flush")
View Source 
var ErrSigNil = errors.New("sig nil")
View Source 
var ErrTimeOutOfRange = errors.New("time out of range")
View Source 
var ErrTooManyFragments = errors.New("too many fragments")
View Source 
var ErrTooMuchData = errors.New("too much data")

Functions

func BinaryMarshalHash 

func BinaryMarshalHash(bMarshal encoding.BinaryMarshaler, h hash.Hash) []byte

func GetUUID 

func GetUUID() [16]byte

func MilliTime 

func MilliTime(t time.Time) time.Time

func PacketDataHash 

func PacketDataHash(packetHeader PacketHeader, payload PacketPayload, h hash.Hash) []byte

Types

type EmptyPayload 

type EmptyPayload struct {
}

EmptyPayload Provides a payload for ConnectionRejectedPacketType, PublicKeyRequestPacketType, SignatureRequestPacketType and SignaturePublicKeyRequestPacketType

func (*EmptyPayload) MarshalHashCalculator 

func (e *EmptyPayload) MarshalHashCalculator() hash.Hash

func (*EmptyPayload) ReadFrom 

func (e *EmptyPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*EmptyPayload) SetCompleteHash 

func (e *EmptyPayload) SetCompleteHash([]byte)

func (*EmptyPayload) Size 

func (e *EmptyPayload) Size() uint

func (*EmptyPayload) WriteTo 

func (e *EmptyPayload) WriteTo(w io.Writer) (n int64, err error)

type FinalProofPayload 

type FinalProofPayload struct {
	ProofHMAC []byte
}

func (*FinalProofPayload) MarshalHashCalculator 

func (f *FinalProofPayload) MarshalHashCalculator() hash.Hash

func (*FinalProofPayload) ReadFrom 

func (f *FinalProofPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*FinalProofPayload) SetCompleteHash 

func (f *FinalProofPayload) SetCompleteHash(bytes []byte)

func (*FinalProofPayload) Size 

func (f *FinalProofPayload) Size() uint

func (*FinalProofPayload) WriteTo 

func (f *FinalProofPayload) WriteTo(w io.Writer) (n int64, err error)

type InitPayload 

type InitPayload struct {

	// PublicKeyHash hash of the local crypto.KemPublicKey
	PublicKeyHash []byte
	// PacketHash contains the hash of the packet when sent by a PacketMarshaller with its header information using PacketHasher
	PacketHash   []byte
	PacketHasher hash.Hash
	// contains filtered or unexported fields
}

func (*InitPayload) Decapsulate 

func (i *InitPayload) Decapsulate(k crypto.KemPrivateKey) (secret []byte, err error)

func (*InitPayload) Encapsulate 

func (i *InitPayload) Encapsulate(k crypto.KemPublicKey) (secret []byte, err error)

Encapsulate can have k nil to clear the stored encapsulation, will still return crypto.ErrKeyNil in this scenario

func (*InitPayload) MarshalHashCalculator 

func (i *InitPayload) MarshalHashCalculator() hash.Hash

func (*InitPayload) ReadFrom 

func (i *InitPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*InitPayload) SetCompleteHash 

func (i *InitPayload) SetCompleteHash(bytes []byte)

func (*InitPayload) Size 

func (i *InitPayload) Size() uint

func (*InitPayload) WriteTo 

func (i *InitPayload) WriteTo(w io.Writer) (n int64, err error)

type InitProofPayload 

type InitProofPayload struct {
	ProofHMAC []byte
	// PacketHash contains the hash of the packet when sent by a PacketMarshaller with its header information using PacketHasher
	PacketHash   []byte
	PacketHasher hash.Hash
	// contains filtered or unexported fields
}

func (*InitProofPayload) Decapsulate 

func (i *InitProofPayload) Decapsulate(k crypto.KemPrivateKey) (secret []byte, err error)

func (*InitProofPayload) Encapsulate 

func (i *InitProofPayload) Encapsulate(k crypto.KemPublicKey) (secret []byte, err error)

Encapsulate can have k nil to clear the stored encapsulation, will still return crypto.ErrKeyNil in this scenario

func (*InitProofPayload) MarshalHashCalculator 

func (i *InitProofPayload) MarshalHashCalculator() hash.Hash

func (*InitProofPayload) ReadFrom 

func (i *InitProofPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*InitProofPayload) SetCompleteHash 

func (i *InitProofPayload) SetCompleteHash(bytes []byte)

func (*InitProofPayload) Size 

func (i *InitProofPayload) Size() uint

func (*InitProofPayload) WriteTo 

func (i *InitProofPayload) WriteTo(w io.Writer) (n int64, err error)

type PacketHeader 

type PacketHeader struct {
	ID             PacketType
	ConnectionUUID [16]byte
	Time           time.Time
	// contains filtered or unexported fields
}

func (*PacketHeader) Clear 

func (h *PacketHeader) Clear()

func (*PacketHeader) Clone 

func (h *PacketHeader) Clone() *PacketHeader

func (*PacketHeader) CloneAsFragment 

func (h *PacketHeader) CloneAsFragment(index, count byte, size uint16) *PacketHeader

func (*PacketHeader) Equals 

func (h *PacketHeader) Equals(other PacketHeader) bool

func (*PacketHeader) GetActualID 

func (h *PacketHeader) GetActualID() PacketType

GetActualID returns the actual ID regardless of IsFragment being true

func (*PacketHeader) IsFragment 

func (h *PacketHeader) IsFragment() bool

func (*PacketHeader) ReadFrom 

func (h *PacketHeader) ReadFrom(r io.Reader) (n int64, err error)

func (*PacketHeader) Set 

func (h *PacketHeader) Set(other PacketHeader)

func (*PacketHeader) WriteTo 

func (h *PacketHeader) WriteTo(w io.Writer) (n int64, err error)

type PacketMarshaller 

type PacketMarshaller struct {
	Conn io.ReadWriter
	// MTU Conn, maximum transmission unit, makes sure packets get fragmented if needed and enables buffer support when > 0; if 0, there is no length limit and no fragmentation
	MTU uint
	// contains filtered or unexported fields
}

func (*PacketMarshaller) ClearFragmentCache 

func (p *PacketMarshaller) ClearFragmentCache()

func (*PacketMarshaller) Marshal 

func (p *PacketMarshaller) Marshal(packetHeader PacketHeader, payload PacketPayload) error

func (*PacketMarshaller) Unmarshal 

func (p *PacketMarshaller) Unmarshal() (packetHeader *PacketHeader, packetPayload PacketPayload, err error)

type PacketPayload 

type PacketPayload interface {
	io.WriterTo
	io.ReaderFrom
	Size() uint
	// MarshalHashCalculator is nil when not supported, provides a way of hashing the packet header and body while marshalling
	MarshalHashCalculator() hash.Hash
	// SetCompleteHash is called once marshaling is complete and MarshalHashCalculator returned a valid hash instance
	SetCompleteHash([]byte)
}

type PacketType 

type PacketType byte

type PublicKeyDataPayload 

type PublicKeyDataPayload struct {
	Data []byte
	// contains filtered or unexported fields
}

func (*PublicKeyDataPayload) Load 

func (p *PublicKeyDataPayload) Load(scheme crypto.KemScheme) (crypto.KemPublicKey, error)

func (*PublicKeyDataPayload) MarshalHashCalculator 

func (p *PublicKeyDataPayload) MarshalHashCalculator() hash.Hash

func (*PublicKeyDataPayload) ReadFrom 

func (p *PublicKeyDataPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*PublicKeyDataPayload) Save 

func (p *PublicKeyDataPayload) Save(key crypto.KemPublicKey) error

func (*PublicKeyDataPayload) SetCompleteHash 

func (p *PublicKeyDataPayload) SetCompleteHash([]byte)

func (*PublicKeyDataPayload) Size 

func (p *PublicKeyDataPayload) Size() uint

func (*PublicKeyDataPayload) WriteTo 

func (p *PublicKeyDataPayload) WriteTo(w io.Writer) (n int64, err error)

type PublicKeySignedPacketPayload 

type PublicKeySignedPacketPayload struct {
	SignatureData []byte
	SigPubKeyHash []byte
	// contains filtered or unexported fields
}

func (*PublicKeySignedPacketPayload) Load 

func (p *PublicKeySignedPacketPayload) Load(kemKeyToCheck crypto.KemPublicKey) (*crypto.SigData, error)

func (*PublicKeySignedPacketPayload) MarshalHashCalculator 

func (p *PublicKeySignedPacketPayload) MarshalHashCalculator() hash.Hash

func (*PublicKeySignedPacketPayload) ReadFrom 

func (p *PublicKeySignedPacketPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*PublicKeySignedPacketPayload) Save 

func (p *PublicKeySignedPacketPayload) Save(sigData *crypto.SigData) (err error)

func (*PublicKeySignedPacketPayload) SetCompleteHash 

func (p *PublicKeySignedPacketPayload) SetCompleteHash([]byte)

func (*PublicKeySignedPacketPayload) Size 

func (p *PublicKeySignedPacketPayload) Size() uint

func (*PublicKeySignedPacketPayload) WriteTo 

func (p *PublicKeySignedPacketPayload) WriteTo(w io.Writer) (n int64, err error)

type SignedPacketPublicKeyPayload 

type SignedPacketPublicKeyPayload struct {
	Data []byte
	// contains filtered or unexported fields
}

func (*SignedPacketPublicKeyPayload) Load 

func (p *SignedPacketPublicKeyPayload) Load(scheme crypto.SigScheme) (crypto.SigPublicKey, error)

func (*SignedPacketPublicKeyPayload) MarshalHashCalculator 

func (p *SignedPacketPublicKeyPayload) MarshalHashCalculator() hash.Hash

func (*SignedPacketPublicKeyPayload) ReadFrom 

func (p *SignedPacketPublicKeyPayload) ReadFrom(r io.Reader) (n int64, err error)

func (*SignedPacketPublicKeyPayload) Save 

func (p *SignedPacketPublicKeyPayload) Save(key crypto.SigPublicKey) error

func (*SignedPacketPublicKeyPayload) SetCompleteHash 

func (p *SignedPacketPublicKeyPayload) SetCompleteHash([]byte)

func (*SignedPacketPublicKeyPayload) Size 

func (p *SignedPacketPublicKeyPayload) Size() uint

func (*SignedPacketPublicKeyPayload) WriteTo 

func (p *SignedPacketPublicKeyPayload) WriteTo(w io.Writer) (n int64, err error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.