IKEV2_TUNNEL_CONFIG_PARAMS4

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CRYPT_INTEGER_BLOB
{
    public uint cbData;
    public IntPtr pbData;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IKEV2_TUNNEL_CONFIG_PARAMS4
{
    public uint dwIdleTimeout;
    public uint dwNetworkBlackoutTime;
    public uint dwSaLifeTime;
    public uint dwSaDataSizeForRenegotiation;
    public uint dwConfigOptions;
    public uint dwTotalCertificates;
    public IntPtr certificateNames;
    public CRYPT_INTEGER_BLOB machineCertificateName;
    public uint dwEncryptionType;
    public IntPtr customPolicy;
    public uint dwTotalEkus;
    public IntPtr certificateEKUs;
    public CRYPT_INTEGER_BLOB machineCertificateHash;
    public uint dwMmSaLifeTime;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CRYPT_INTEGER_BLOB
    Public cbData As UInteger
    Public pbData As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IKEV2_TUNNEL_CONFIG_PARAMS4
    Public dwIdleTimeout As UInteger
    Public dwNetworkBlackoutTime As UInteger
    Public dwSaLifeTime As UInteger
    Public dwSaDataSizeForRenegotiation As UInteger
    Public dwConfigOptions As UInteger
    Public dwTotalCertificates As UInteger
    Public certificateNames As IntPtr
    Public machineCertificateName As CRYPT_INTEGER_BLOB
    Public dwEncryptionType As UInteger
    Public customPolicy As IntPtr
    Public dwTotalEkus As UInteger
    Public certificateEKUs As IntPtr
    Public machineCertificateHash As CRYPT_INTEGER_BLOB
    Public dwMmSaLifeTime As UInteger
End Structure

import ctypes
from ctypes import wintypes

class CRYPT_INTEGER_BLOB(ctypes.Structure):
    _fields_ = [
        ("cbData", wintypes.DWORD),
        ("pbData", ctypes.c_void_p),
    ]

class IKEV2_TUNNEL_CONFIG_PARAMS4(ctypes.Structure):
    _fields_ = [
        ("dwIdleTimeout", wintypes.DWORD),
        ("dwNetworkBlackoutTime", wintypes.DWORD),
        ("dwSaLifeTime", wintypes.DWORD),
        ("dwSaDataSizeForRenegotiation", wintypes.DWORD),
        ("dwConfigOptions", wintypes.DWORD),
        ("dwTotalCertificates", wintypes.DWORD),
        ("certificateNames", ctypes.c_void_p),
        ("machineCertificateName", CRYPT_INTEGER_BLOB),
        ("dwEncryptionType", wintypes.DWORD),
        ("customPolicy", ctypes.c_void_p),
        ("dwTotalEkus", wintypes.DWORD),
        ("certificateEKUs", ctypes.c_void_p),
        ("machineCertificateHash", CRYPT_INTEGER_BLOB),
        ("dwMmSaLifeTime", wintypes.DWORD),
    ]

#[repr(C)]
pub struct CRYPT_INTEGER_BLOB {
    pub cbData: u32,
    pub pbData: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct IKEV2_TUNNEL_CONFIG_PARAMS4 {
    pub dwIdleTimeout: u32,
    pub dwNetworkBlackoutTime: u32,
    pub dwSaLifeTime: u32,
    pub dwSaDataSizeForRenegotiation: u32,
    pub dwConfigOptions: u32,
    pub dwTotalCertificates: u32,
    pub certificateNames: *mut core::ffi::c_void,
    pub machineCertificateName: CRYPT_INTEGER_BLOB,
    pub dwEncryptionType: u32,
    pub customPolicy: *mut core::ffi::c_void,
    pub dwTotalEkus: u32,
    pub certificateEKUs: *mut core::ffi::c_void,
    pub machineCertificateHash: CRYPT_INTEGER_BLOB,
    pub dwMmSaLifeTime: u32,
}

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

type CRYPT_INTEGER_BLOB struct {
	cbData uint32
	pbData uintptr
}

type IKEV2_TUNNEL_CONFIG_PARAMS4 struct {
	dwIdleTimeout uint32
	dwNetworkBlackoutTime uint32
	dwSaLifeTime uint32
	dwSaDataSizeForRenegotiation uint32
	dwConfigOptions uint32
	dwTotalCertificates uint32
	certificateNames uintptr
	machineCertificateName CRYPT_INTEGER_BLOB
	dwEncryptionType uint32
	customPolicy uintptr
	dwTotalEkus uint32
	certificateEKUs uintptr
	machineCertificateHash CRYPT_INTEGER_BLOB
	dwMmSaLifeTime uint32
}

type
  CRYPT_INTEGER_BLOB = record
    cbData: DWORD;
    pbData: Pointer;
  end;

  IKEV2_TUNNEL_CONFIG_PARAMS4 = record
    dwIdleTimeout: DWORD;
    dwNetworkBlackoutTime: DWORD;
    dwSaLifeTime: DWORD;
    dwSaDataSizeForRenegotiation: DWORD;
    dwConfigOptions: DWORD;
    dwTotalCertificates: DWORD;
    certificateNames: Pointer;
    machineCertificateName: CRYPT_INTEGER_BLOB;
    dwEncryptionType: DWORD;
    customPolicy: Pointer;
    dwTotalEkus: DWORD;
    certificateEKUs: Pointer;
    machineCertificateHash: CRYPT_INTEGER_BLOB;
    dwMmSaLifeTime: DWORD;
  end;

const CRYPT_INTEGER_BLOB = extern struct {
    cbData: u32,
    pbData: ?*anyopaque,
};

const IKEV2_TUNNEL_CONFIG_PARAMS4 = extern struct {
    dwIdleTimeout: u32,
    dwNetworkBlackoutTime: u32,
    dwSaLifeTime: u32,
    dwSaDataSizeForRenegotiation: u32,
    dwConfigOptions: u32,
    dwTotalCertificates: u32,
    certificateNames: ?*anyopaque,
    machineCertificateName: CRYPT_INTEGER_BLOB,
    dwEncryptionType: u32,
    customPolicy: ?*anyopaque,
    dwTotalEkus: u32,
    certificateEKUs: ?*anyopaque,
    machineCertificateHash: CRYPT_INTEGER_BLOB,
    dwMmSaLifeTime: u32,
};

type
  CRYPT_INTEGER_BLOB {.bycopy.} = object
    cbData: uint32
    pbData: pointer

  IKEV2_TUNNEL_CONFIG_PARAMS4 {.bycopy.} = object
    dwIdleTimeout: uint32
    dwNetworkBlackoutTime: uint32
    dwSaLifeTime: uint32
    dwSaDataSizeForRenegotiation: uint32
    dwConfigOptions: uint32
    dwTotalCertificates: uint32
    certificateNames: pointer
    machineCertificateName: CRYPT_INTEGER_BLOB
    dwEncryptionType: uint32
    customPolicy: pointer
    dwTotalEkus: uint32
    certificateEKUs: pointer
    machineCertificateHash: CRYPT_INTEGER_BLOB
    dwMmSaLifeTime: uint32

struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct IKEV2_TUNNEL_CONFIG_PARAMS4
{
    uint dwIdleTimeout;
    uint dwNetworkBlackoutTime;
    uint dwSaLifeTime;
    uint dwSaDataSizeForRenegotiation;
    uint dwConfigOptions;
    uint dwTotalCertificates;
    void* certificateNames;
    CRYPT_INTEGER_BLOB machineCertificateName;
    uint dwEncryptionType;
    void* customPolicy;
    uint dwTotalEkus;
    void* certificateEKUs;
    CRYPT_INTEGER_BLOB machineCertificateHash;
    uint dwMmSaLifeTime;
}