334 lines
7.7 KiB
Go
334 lines
7.7 KiB
Go
package nl
|
|
|
|
import (
|
|
"unsafe"
|
|
)
|
|
|
|
const (
|
|
SizeofXfrmUsersaId = 0x18
|
|
SizeofXfrmStats = 0x0c
|
|
SizeofXfrmUsersaInfo = 0xe0
|
|
SizeofXfrmUserSpiInfo = 0xe8
|
|
SizeofXfrmAlgo = 0x44
|
|
SizeofXfrmAlgoAuth = 0x48
|
|
SizeofXfrmAlgoAEAD = 0x48
|
|
SizeofXfrmEncapTmpl = 0x18
|
|
SizeofXfrmUsersaFlush = 0x8
|
|
SizeofXfrmReplayStateEsn = 0x18
|
|
)
|
|
|
|
const (
|
|
XFRM_STATE_NOECN = 1
|
|
XFRM_STATE_DECAP_DSCP = 2
|
|
XFRM_STATE_NOPMTUDISC = 4
|
|
XFRM_STATE_WILDRECV = 8
|
|
XFRM_STATE_ICMP = 16
|
|
XFRM_STATE_AF_UNSPEC = 32
|
|
XFRM_STATE_ALIGN4 = 64
|
|
XFRM_STATE_ESN = 128
|
|
)
|
|
|
|
// struct xfrm_usersa_id {
|
|
// xfrm_address_t daddr;
|
|
// __be32 spi;
|
|
// __u16 family;
|
|
// __u8 proto;
|
|
// };
|
|
|
|
type XfrmUsersaId struct {
|
|
Daddr XfrmAddress
|
|
Spi uint32 // big endian
|
|
Family uint16
|
|
Proto uint8
|
|
Pad byte
|
|
}
|
|
|
|
func (msg *XfrmUsersaId) Len() int {
|
|
return SizeofXfrmUsersaId
|
|
}
|
|
|
|
func DeserializeXfrmUsersaId(b []byte) *XfrmUsersaId {
|
|
return (*XfrmUsersaId)(unsafe.Pointer(&b[0:SizeofXfrmUsersaId][0]))
|
|
}
|
|
|
|
func (msg *XfrmUsersaId) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUsersaId]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_stats {
|
|
// __u32 replay_window;
|
|
// __u32 replay;
|
|
// __u32 integrity_failed;
|
|
// };
|
|
|
|
type XfrmStats struct {
|
|
ReplayWindow uint32
|
|
Replay uint32
|
|
IntegrityFailed uint32
|
|
}
|
|
|
|
func (msg *XfrmStats) Len() int {
|
|
return SizeofXfrmStats
|
|
}
|
|
|
|
func DeserializeXfrmStats(b []byte) *XfrmStats {
|
|
return (*XfrmStats)(unsafe.Pointer(&b[0:SizeofXfrmStats][0]))
|
|
}
|
|
|
|
func (msg *XfrmStats) Serialize() []byte {
|
|
return (*(*[SizeofXfrmStats]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_usersa_info {
|
|
// struct xfrm_selector sel;
|
|
// struct xfrm_id id;
|
|
// xfrm_address_t saddr;
|
|
// struct xfrm_lifetime_cfg lft;
|
|
// struct xfrm_lifetime_cur curlft;
|
|
// struct xfrm_stats stats;
|
|
// __u32 seq;
|
|
// __u32 reqid;
|
|
// __u16 family;
|
|
// __u8 mode; /* XFRM_MODE_xxx */
|
|
// __u8 replay_window;
|
|
// __u8 flags;
|
|
// #define XFRM_STATE_NOECN 1
|
|
// #define XFRM_STATE_DECAP_DSCP 2
|
|
// #define XFRM_STATE_NOPMTUDISC 4
|
|
// #define XFRM_STATE_WILDRECV 8
|
|
// #define XFRM_STATE_ICMP 16
|
|
// #define XFRM_STATE_AF_UNSPEC 32
|
|
// #define XFRM_STATE_ALIGN4 64
|
|
// #define XFRM_STATE_ESN 128
|
|
// };
|
|
//
|
|
// #define XFRM_SA_XFLAG_DONT_ENCAP_DSCP 1
|
|
//
|
|
|
|
type XfrmUsersaInfo struct {
|
|
Sel XfrmSelector
|
|
Id XfrmId
|
|
Saddr XfrmAddress
|
|
Lft XfrmLifetimeCfg
|
|
Curlft XfrmLifetimeCur
|
|
Stats XfrmStats
|
|
Seq uint32
|
|
Reqid uint32
|
|
Family uint16
|
|
Mode uint8
|
|
ReplayWindow uint8
|
|
Flags uint8
|
|
Pad [7]byte
|
|
}
|
|
|
|
func (msg *XfrmUsersaInfo) Len() int {
|
|
return SizeofXfrmUsersaInfo
|
|
}
|
|
|
|
func DeserializeXfrmUsersaInfo(b []byte) *XfrmUsersaInfo {
|
|
return (*XfrmUsersaInfo)(unsafe.Pointer(&b[0:SizeofXfrmUsersaInfo][0]))
|
|
}
|
|
|
|
func (msg *XfrmUsersaInfo) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUsersaInfo]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_userspi_info {
|
|
// struct xfrm_usersa_info info;
|
|
// __u32 min;
|
|
// __u32 max;
|
|
// };
|
|
|
|
type XfrmUserSpiInfo struct {
|
|
XfrmUsersaInfo XfrmUsersaInfo
|
|
Min uint32
|
|
Max uint32
|
|
}
|
|
|
|
func (msg *XfrmUserSpiInfo) Len() int {
|
|
return SizeofXfrmUserSpiInfo
|
|
}
|
|
|
|
func DeserializeXfrmUserSpiInfo(b []byte) *XfrmUserSpiInfo {
|
|
return (*XfrmUserSpiInfo)(unsafe.Pointer(&b[0:SizeofXfrmUserSpiInfo][0]))
|
|
}
|
|
|
|
func (msg *XfrmUserSpiInfo) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUserSpiInfo]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_algo {
|
|
// char alg_name[64];
|
|
// unsigned int alg_key_len; /* in bits */
|
|
// char alg_key[0];
|
|
// };
|
|
|
|
type XfrmAlgo struct {
|
|
AlgName [64]byte
|
|
AlgKeyLen uint32
|
|
AlgKey []byte
|
|
}
|
|
|
|
func (msg *XfrmAlgo) Len() int {
|
|
return SizeofXfrmAlgo + int(msg.AlgKeyLen/8)
|
|
}
|
|
|
|
func DeserializeXfrmAlgo(b []byte) *XfrmAlgo {
|
|
ret := XfrmAlgo{}
|
|
copy(ret.AlgName[:], b[0:64])
|
|
ret.AlgKeyLen = *(*uint32)(unsafe.Pointer(&b[64]))
|
|
ret.AlgKey = b[68:ret.Len()]
|
|
return &ret
|
|
}
|
|
|
|
func (msg *XfrmAlgo) Serialize() []byte {
|
|
b := make([]byte, msg.Len())
|
|
copy(b[0:64], msg.AlgName[:])
|
|
copy(b[64:68], (*(*[4]byte)(unsafe.Pointer(&msg.AlgKeyLen)))[:])
|
|
copy(b[68:msg.Len()], msg.AlgKey[:])
|
|
return b
|
|
}
|
|
|
|
// struct xfrm_algo_auth {
|
|
// char alg_name[64];
|
|
// unsigned int alg_key_len; /* in bits */
|
|
// unsigned int alg_trunc_len; /* in bits */
|
|
// char alg_key[0];
|
|
// };
|
|
|
|
type XfrmAlgoAuth struct {
|
|
AlgName [64]byte
|
|
AlgKeyLen uint32
|
|
AlgTruncLen uint32
|
|
AlgKey []byte
|
|
}
|
|
|
|
func (msg *XfrmAlgoAuth) Len() int {
|
|
return SizeofXfrmAlgoAuth + int(msg.AlgKeyLen/8)
|
|
}
|
|
|
|
func DeserializeXfrmAlgoAuth(b []byte) *XfrmAlgoAuth {
|
|
ret := XfrmAlgoAuth{}
|
|
copy(ret.AlgName[:], b[0:64])
|
|
ret.AlgKeyLen = *(*uint32)(unsafe.Pointer(&b[64]))
|
|
ret.AlgTruncLen = *(*uint32)(unsafe.Pointer(&b[68]))
|
|
ret.AlgKey = b[72:ret.Len()]
|
|
return &ret
|
|
}
|
|
|
|
func (msg *XfrmAlgoAuth) Serialize() []byte {
|
|
b := make([]byte, msg.Len())
|
|
copy(b[0:64], msg.AlgName[:])
|
|
copy(b[64:68], (*(*[4]byte)(unsafe.Pointer(&msg.AlgKeyLen)))[:])
|
|
copy(b[68:72], (*(*[4]byte)(unsafe.Pointer(&msg.AlgTruncLen)))[:])
|
|
copy(b[72:msg.Len()], msg.AlgKey[:])
|
|
return b
|
|
}
|
|
|
|
// struct xfrm_algo_aead {
|
|
// char alg_name[64];
|
|
// unsigned int alg_key_len; /* in bits */
|
|
// unsigned int alg_icv_len; /* in bits */
|
|
// char alg_key[0];
|
|
// }
|
|
|
|
type XfrmAlgoAEAD struct {
|
|
AlgName [64]byte
|
|
AlgKeyLen uint32
|
|
AlgICVLen uint32
|
|
AlgKey []byte
|
|
}
|
|
|
|
func (msg *XfrmAlgoAEAD) Len() int {
|
|
return SizeofXfrmAlgoAEAD + int(msg.AlgKeyLen/8)
|
|
}
|
|
|
|
func DeserializeXfrmAlgoAEAD(b []byte) *XfrmAlgoAEAD {
|
|
ret := XfrmAlgoAEAD{}
|
|
copy(ret.AlgName[:], b[0:64])
|
|
ret.AlgKeyLen = *(*uint32)(unsafe.Pointer(&b[64]))
|
|
ret.AlgICVLen = *(*uint32)(unsafe.Pointer(&b[68]))
|
|
ret.AlgKey = b[72:ret.Len()]
|
|
return &ret
|
|
}
|
|
|
|
func (msg *XfrmAlgoAEAD) Serialize() []byte {
|
|
b := make([]byte, msg.Len())
|
|
copy(b[0:64], msg.AlgName[:])
|
|
copy(b[64:68], (*(*[4]byte)(unsafe.Pointer(&msg.AlgKeyLen)))[:])
|
|
copy(b[68:72], (*(*[4]byte)(unsafe.Pointer(&msg.AlgICVLen)))[:])
|
|
copy(b[72:msg.Len()], msg.AlgKey[:])
|
|
return b
|
|
}
|
|
|
|
// struct xfrm_encap_tmpl {
|
|
// __u16 encap_type;
|
|
// __be16 encap_sport;
|
|
// __be16 encap_dport;
|
|
// xfrm_address_t encap_oa;
|
|
// };
|
|
|
|
type XfrmEncapTmpl struct {
|
|
EncapType uint16
|
|
EncapSport uint16 // big endian
|
|
EncapDport uint16 // big endian
|
|
Pad [2]byte
|
|
EncapOa XfrmAddress
|
|
}
|
|
|
|
func (msg *XfrmEncapTmpl) Len() int {
|
|
return SizeofXfrmEncapTmpl
|
|
}
|
|
|
|
func DeserializeXfrmEncapTmpl(b []byte) *XfrmEncapTmpl {
|
|
return (*XfrmEncapTmpl)(unsafe.Pointer(&b[0:SizeofXfrmEncapTmpl][0]))
|
|
}
|
|
|
|
func (msg *XfrmEncapTmpl) Serialize() []byte {
|
|
return (*(*[SizeofXfrmEncapTmpl]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_usersa_flush {
|
|
// __u8 proto;
|
|
// };
|
|
|
|
type XfrmUsersaFlush struct {
|
|
Proto uint8
|
|
}
|
|
|
|
func (msg *XfrmUsersaFlush) Len() int {
|
|
return SizeofXfrmUsersaFlush
|
|
}
|
|
|
|
func DeserializeXfrmUsersaFlush(b []byte) *XfrmUsersaFlush {
|
|
return (*XfrmUsersaFlush)(unsafe.Pointer(&b[0:SizeofXfrmUsersaFlush][0]))
|
|
}
|
|
|
|
func (msg *XfrmUsersaFlush) Serialize() []byte {
|
|
return (*(*[SizeofXfrmUsersaFlush]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|
|
|
|
// struct xfrm_replay_state_esn {
|
|
// unsigned int bmp_len;
|
|
// __u32 oseq;
|
|
// __u32 seq;
|
|
// __u32 oseq_hi;
|
|
// __u32 seq_hi;
|
|
// __u32 replay_window;
|
|
// __u32 bmp[0];
|
|
// };
|
|
|
|
type XfrmReplayStateEsn struct {
|
|
BmpLen uint32
|
|
OSeq uint32
|
|
Seq uint32
|
|
OSeqHi uint32
|
|
SeqHi uint32
|
|
ReplayWindow uint32
|
|
Bmp []uint32
|
|
}
|
|
|
|
func (msg *XfrmReplayStateEsn) Serialize() []byte {
|
|
// We deliberately do not pass Bmp, as it gets set by the kernel.
|
|
return (*(*[SizeofXfrmReplayStateEsn]byte)(unsafe.Pointer(msg)))[:]
|
|
}
|