FWPM_CONNECTION0

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEEXT_CIPHER_ALGORITHM0
{
    public int algoIdentifier;
    public uint keyLen;
    public uint rounds;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEEXT_INTEGRITY_ALGORITHM0
{
    public int algoIdentifier;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEEXT_PROPOSAL0
{
    public IKEEXT_CIPHER_ALGORITHM0 cipherAlgorithm;
    public IKEEXT_INTEGRITY_ALGORITHM0 integrityAlgorithm;
    public uint maxLifetimeSeconds;
    public int dhGroup;
    public uint quickModeLimit;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEEXT_CREDENTIAL2
{
    public int authenticationMethodType;
    public int impersonationType;
    public _Anonymous_e__Union Anonymous;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FILETIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FWPM_CONNECTION0
{
    public ulong connectionId;
    public int ipVersion;
    public _Anonymous1_e__Union Anonymous1;
    public _Anonymous2_e__Union Anonymous2;
    public IntPtr providerKey;
    public int ipsecTrafficModeType;
    public int keyModuleType;
    public IKEEXT_PROPOSAL0 mmCrypto;
    public IKEEXT_CREDENTIAL2 mmPeer;
    public IKEEXT_CREDENTIAL2 emPeer;
    public ulong bytesTransferredIn;
    public ulong bytesTransferredOut;
    public ulong bytesTransferredTotal;
    public FILETIME startSysTime;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEEXT_CIPHER_ALGORITHM0
    Public algoIdentifier As Integer
    Public keyLen As UInteger
    Public rounds As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEEXT_INTEGRITY_ALGORITHM0
    Public algoIdentifier As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEEXT_PROPOSAL0
    Public cipherAlgorithm As IKEEXT_CIPHER_ALGORITHM0
    Public integrityAlgorithm As IKEEXT_INTEGRITY_ALGORITHM0
    Public maxLifetimeSeconds As UInteger
    Public dhGroup As Integer
    Public quickModeLimit As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEEXT_CREDENTIAL2
    Public authenticationMethodType As Integer
    Public impersonationType As Integer
    Public Anonymous As _Anonymous_e__Union
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FILETIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FWPM_CONNECTION0
    Public connectionId As ULong
    Public ipVersion As Integer
    Public Anonymous1 As _Anonymous1_e__Union
    Public Anonymous2 As _Anonymous2_e__Union
    Public providerKey As IntPtr
    Public ipsecTrafficModeType As Integer
    Public keyModuleType As Integer
    Public mmCrypto As IKEEXT_PROPOSAL0
    Public mmPeer As IKEEXT_CREDENTIAL2
    Public emPeer As IKEEXT_CREDENTIAL2
    Public bytesTransferredIn As ULong
    Public bytesTransferredOut As ULong
    Public bytesTransferredTotal As ULong
    Public startSysTime As FILETIME
End Structure

import ctypes
from ctypes import wintypes

class IKEEXT_CIPHER_ALGORITHM0(ctypes.Structure):
    _fields_ = [
        ("algoIdentifier", ctypes.c_int),
        ("keyLen", wintypes.DWORD),
        ("rounds", wintypes.DWORD),
    ]

class IKEEXT_INTEGRITY_ALGORITHM0(ctypes.Structure):
    _fields_ = [
        ("algoIdentifier", ctypes.c_int),
    ]

class IKEEXT_PROPOSAL0(ctypes.Structure):
    _fields_ = [
        ("cipherAlgorithm", IKEEXT_CIPHER_ALGORITHM0),
        ("integrityAlgorithm", IKEEXT_INTEGRITY_ALGORITHM0),
        ("maxLifetimeSeconds", wintypes.DWORD),
        ("dhGroup", ctypes.c_int),
        ("quickModeLimit", wintypes.DWORD),
    ]

class IKEEXT_CREDENTIAL2(ctypes.Structure):
    _fields_ = [
        ("authenticationMethodType", ctypes.c_int),
        ("impersonationType", ctypes.c_int),
        ("Anonymous", _Anonymous_e__Union),
    ]

class FILETIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class FWPM_CONNECTION0(ctypes.Structure):
    _fields_ = [
        ("connectionId", ctypes.c_ulonglong),
        ("ipVersion", ctypes.c_int),
        ("Anonymous1", _Anonymous1_e__Union),
        ("Anonymous2", _Anonymous2_e__Union),
        ("providerKey", ctypes.c_void_p),
        ("ipsecTrafficModeType", ctypes.c_int),
        ("keyModuleType", ctypes.c_int),
        ("mmCrypto", IKEEXT_PROPOSAL0),
        ("mmPeer", IKEEXT_CREDENTIAL2),
        ("emPeer", IKEEXT_CREDENTIAL2),
        ("bytesTransferredIn", ctypes.c_ulonglong),
        ("bytesTransferredOut", ctypes.c_ulonglong),
        ("bytesTransferredTotal", ctypes.c_ulonglong),
        ("startSysTime", FILETIME),
    ]

#[repr(C)]
pub struct IKEEXT_CIPHER_ALGORITHM0 {
    pub algoIdentifier: i32,
    pub keyLen: u32,
    pub rounds: u32,
}

#[repr(C)]
pub struct IKEEXT_INTEGRITY_ALGORITHM0 {
    pub algoIdentifier: i32,
}

#[repr(C)]
pub struct IKEEXT_PROPOSAL0 {
    pub cipherAlgorithm: IKEEXT_CIPHER_ALGORITHM0,
    pub integrityAlgorithm: IKEEXT_INTEGRITY_ALGORITHM0,
    pub maxLifetimeSeconds: u32,
    pub dhGroup: i32,
    pub quickModeLimit: u32,
}

#[repr(C)]
pub struct IKEEXT_CREDENTIAL2 {
    pub authenticationMethodType: i32,
    pub impersonationType: i32,
    pub Anonymous: _Anonymous_e__Union,
}

#[repr(C)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct FWPM_CONNECTION0 {
    pub connectionId: u64,
    pub ipVersion: i32,
    pub Anonymous1: _Anonymous1_e__Union,
    pub Anonymous2: _Anonymous2_e__Union,
    pub providerKey: *mut core::ffi::c_void,
    pub ipsecTrafficModeType: i32,
    pub keyModuleType: i32,
    pub mmCrypto: IKEEXT_PROPOSAL0,
    pub mmPeer: IKEEXT_CREDENTIAL2,
    pub emPeer: IKEEXT_CREDENTIAL2,
    pub bytesTransferredIn: u64,
    pub bytesTransferredOut: u64,
    pub bytesTransferredTotal: u64,
    pub startSysTime: FILETIME,
}

import "golang.org/x/sys/windows"

type IKEEXT_CIPHER_ALGORITHM0 struct {
	algoIdentifier int32
	keyLen uint32
	rounds uint32
}

type IKEEXT_INTEGRITY_ALGORITHM0 struct {
	algoIdentifier int32
}

type IKEEXT_PROPOSAL0 struct {
	cipherAlgorithm IKEEXT_CIPHER_ALGORITHM0
	integrityAlgorithm IKEEXT_INTEGRITY_ALGORITHM0
	maxLifetimeSeconds uint32
	dhGroup int32
	quickModeLimit uint32
}

type IKEEXT_CREDENTIAL2 struct {
	authenticationMethodType int32
	impersonationType int32
	Anonymous _Anonymous_e__Union
}

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type FWPM_CONNECTION0 struct {
	connectionId uint64
	ipVersion int32
	Anonymous1 _Anonymous1_e__Union
	Anonymous2 _Anonymous2_e__Union
	providerKey uintptr
	ipsecTrafficModeType int32
	keyModuleType int32
	mmCrypto IKEEXT_PROPOSAL0
	mmPeer IKEEXT_CREDENTIAL2
	emPeer IKEEXT_CREDENTIAL2
	bytesTransferredIn uint64
	bytesTransferredOut uint64
	bytesTransferredTotal uint64
	startSysTime FILETIME
}

type
  IKEEXT_CIPHER_ALGORITHM0 = record
    algoIdentifier: Integer;
    keyLen: DWORD;
    rounds: DWORD;
  end;

  IKEEXT_INTEGRITY_ALGORITHM0 = record
    algoIdentifier: Integer;
  end;

  IKEEXT_PROPOSAL0 = record
    cipherAlgorithm: IKEEXT_CIPHER_ALGORITHM0;
    integrityAlgorithm: IKEEXT_INTEGRITY_ALGORITHM0;
    maxLifetimeSeconds: DWORD;
    dhGroup: Integer;
    quickModeLimit: DWORD;
  end;

  IKEEXT_CREDENTIAL2 = record
    authenticationMethodType: Integer;
    impersonationType: Integer;
    Anonymous: _Anonymous_e__Union;
  end;

  FILETIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  FWPM_CONNECTION0 = record
    connectionId: UInt64;
    ipVersion: Integer;
    Anonymous1: _Anonymous1_e__Union;
    Anonymous2: _Anonymous2_e__Union;
    providerKey: Pointer;
    ipsecTrafficModeType: Integer;
    keyModuleType: Integer;
    mmCrypto: IKEEXT_PROPOSAL0;
    mmPeer: IKEEXT_CREDENTIAL2;
    emPeer: IKEEXT_CREDENTIAL2;
    bytesTransferredIn: UInt64;
    bytesTransferredOut: UInt64;
    bytesTransferredTotal: UInt64;
    startSysTime: FILETIME;
  end;

const IKEEXT_CIPHER_ALGORITHM0 = extern struct {
    algoIdentifier: i32,
    keyLen: u32,
    rounds: u32,
};

const IKEEXT_INTEGRITY_ALGORITHM0 = extern struct {
    algoIdentifier: i32,
};

const IKEEXT_PROPOSAL0 = extern struct {
    cipherAlgorithm: IKEEXT_CIPHER_ALGORITHM0,
    integrityAlgorithm: IKEEXT_INTEGRITY_ALGORITHM0,
    maxLifetimeSeconds: u32,
    dhGroup: i32,
    quickModeLimit: u32,
};

const IKEEXT_CREDENTIAL2 = extern struct {
    authenticationMethodType: i32,
    impersonationType: i32,
    Anonymous: _Anonymous_e__Union,
};

const FILETIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const FWPM_CONNECTION0 = extern struct {
    connectionId: u64,
    ipVersion: i32,
    Anonymous1: _Anonymous1_e__Union,
    Anonymous2: _Anonymous2_e__Union,
    providerKey: ?*anyopaque,
    ipsecTrafficModeType: i32,
    keyModuleType: i32,
    mmCrypto: IKEEXT_PROPOSAL0,
    mmPeer: IKEEXT_CREDENTIAL2,
    emPeer: IKEEXT_CREDENTIAL2,
    bytesTransferredIn: u64,
    bytesTransferredOut: u64,
    bytesTransferredTotal: u64,
    startSysTime: FILETIME,
};

type
  IKEEXT_CIPHER_ALGORITHM0 {.bycopy.} = object
    algoIdentifier: int32
    keyLen: uint32
    rounds: uint32

  IKEEXT_INTEGRITY_ALGORITHM0 {.bycopy.} = object
    algoIdentifier: int32

  IKEEXT_PROPOSAL0 {.bycopy.} = object
    cipherAlgorithm: IKEEXT_CIPHER_ALGORITHM0
    integrityAlgorithm: IKEEXT_INTEGRITY_ALGORITHM0
    maxLifetimeSeconds: uint32
    dhGroup: int32
    quickModeLimit: uint32

  IKEEXT_CREDENTIAL2 {.bycopy.} = object
    authenticationMethodType: int32
    impersonationType: int32
    Anonymous: _Anonymous_e__Union

  FILETIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  FWPM_CONNECTION0 {.bycopy.} = object
    connectionId: uint64
    ipVersion: int32
    Anonymous1: _Anonymous1_e__Union
    Anonymous2: _Anonymous2_e__Union
    providerKey: pointer
    ipsecTrafficModeType: int32
    keyModuleType: int32
    mmCrypto: IKEEXT_PROPOSAL0
    mmPeer: IKEEXT_CREDENTIAL2
    emPeer: IKEEXT_CREDENTIAL2
    bytesTransferredIn: uint64
    bytesTransferredOut: uint64
    bytesTransferredTotal: uint64
    startSysTime: FILETIME

struct IKEEXT_CIPHER_ALGORITHM0
{
    int algoIdentifier;
    uint keyLen;
    uint rounds;
}

struct IKEEXT_INTEGRITY_ALGORITHM0
{
    int algoIdentifier;
}

struct IKEEXT_PROPOSAL0
{
    IKEEXT_CIPHER_ALGORITHM0 cipherAlgorithm;
    IKEEXT_INTEGRITY_ALGORITHM0 integrityAlgorithm;
    uint maxLifetimeSeconds;
    int dhGroup;
    uint quickModeLimit;
}

struct IKEEXT_CREDENTIAL2
{
    int authenticationMethodType;
    int impersonationType;
    _Anonymous_e__Union Anonymous;
}

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct FWPM_CONNECTION0
{
    ulong connectionId;
    int ipVersion;
    _Anonymous1_e__Union Anonymous1;
    _Anonymous2_e__Union Anonymous2;
    void* providerKey;
    int ipsecTrafficModeType;
    int keyModuleType;
    IKEEXT_PROPOSAL0 mmCrypto;
    IKEEXT_CREDENTIAL2 mmPeer;
    IKEEXT_CREDENTIAL2 emPeer;
    ulong bytesTransferredIn;
    ulong bytesTransferredOut;
    ulong bytesTransferredTotal;
    FILETIME startSysTime;
}