SIP_SUBJECTINFO

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 CRYPT_ALGORITHM_IDENTIFIER
{
    public IntPtr pszObjId;
    public CRYPT_INTEGER_BLOB Parameters;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SIP_SUBJECTINFO
{
    public uint cbSize;
    public IntPtr pgSubjectType;
    public IntPtr hFile;
    public IntPtr pwsFileName;
    public IntPtr pwsDisplayName;
    public uint dwReserved1;
    public uint dwIntVersion;
    public UIntPtr hProv;
    public CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
    public uint dwFlags;
    public uint dwEncodingType;
    public uint dwReserved2;
    public uint fdwCAPISettings;
    public uint fdwSecuritySettings;
    public uint dwIndex;
    public uint dwUnionChoice;
    public _Anonymous_e__Union Anonymous;
    public IntPtr pClientData;
}

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 CRYPT_ALGORITHM_IDENTIFIER
    Public pszObjId As IntPtr
    Public Parameters As CRYPT_INTEGER_BLOB
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SIP_SUBJECTINFO
    Public cbSize As UInteger
    Public pgSubjectType As IntPtr
    Public hFile As IntPtr
    Public pwsFileName As IntPtr
    Public pwsDisplayName As IntPtr
    Public dwReserved1 As UInteger
    Public dwIntVersion As UInteger
    Public hProv As UIntPtr
    Public DigestAlgorithm As CRYPT_ALGORITHM_IDENTIFIER
    Public dwFlags As UInteger
    Public dwEncodingType As UInteger
    Public dwReserved2 As UInteger
    Public fdwCAPISettings As UInteger
    Public fdwSecuritySettings As UInteger
    Public dwIndex As UInteger
    Public dwUnionChoice As UInteger
    Public Anonymous As _Anonymous_e__Union
    Public pClientData As IntPtr
End Structure

import ctypes
from ctypes import wintypes

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

class CRYPT_ALGORITHM_IDENTIFIER(ctypes.Structure):
    _fields_ = [
        ("pszObjId", ctypes.c_void_p),
        ("Parameters", CRYPT_INTEGER_BLOB),
    ]

class SIP_SUBJECTINFO(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("pgSubjectType", ctypes.c_void_p),
        ("hFile", ctypes.c_void_p),
        ("pwsFileName", ctypes.c_void_p),
        ("pwsDisplayName", ctypes.c_void_p),
        ("dwReserved1", wintypes.DWORD),
        ("dwIntVersion", wintypes.DWORD),
        ("hProv", ctypes.c_size_t),
        ("DigestAlgorithm", CRYPT_ALGORITHM_IDENTIFIER),
        ("dwFlags", wintypes.DWORD),
        ("dwEncodingType", wintypes.DWORD),
        ("dwReserved2", wintypes.DWORD),
        ("fdwCAPISettings", wintypes.DWORD),
        ("fdwSecuritySettings", wintypes.DWORD),
        ("dwIndex", wintypes.DWORD),
        ("dwUnionChoice", wintypes.DWORD),
        ("Anonymous", _Anonymous_e__Union),
        ("pClientData", ctypes.c_void_p),
    ]

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

#[repr(C)]
pub struct CRYPT_ALGORITHM_IDENTIFIER {
    pub pszObjId: *mut core::ffi::c_void,
    pub Parameters: CRYPT_INTEGER_BLOB,
}

#[repr(C)]
pub struct SIP_SUBJECTINFO {
    pub cbSize: u32,
    pub pgSubjectType: *mut core::ffi::c_void,
    pub hFile: *mut core::ffi::c_void,
    pub pwsFileName: *mut core::ffi::c_void,
    pub pwsDisplayName: *mut core::ffi::c_void,
    pub dwReserved1: u32,
    pub dwIntVersion: u32,
    pub hProv: usize,
    pub DigestAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pub dwFlags: u32,
    pub dwEncodingType: u32,
    pub dwReserved2: u32,
    pub fdwCAPISettings: u32,
    pub fdwSecuritySettings: u32,
    pub dwIndex: u32,
    pub dwUnionChoice: u32,
    pub Anonymous: _Anonymous_e__Union,
    pub pClientData: *mut core::ffi::c_void,
}

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

type CRYPT_INTEGER_BLOB struct {
	cbData uint32
	pbData uintptr
}

type CRYPT_ALGORITHM_IDENTIFIER struct {
	pszObjId uintptr
	Parameters CRYPT_INTEGER_BLOB
}

type SIP_SUBJECTINFO struct {
	cbSize uint32
	pgSubjectType uintptr
	hFile uintptr
	pwsFileName uintptr
	pwsDisplayName uintptr
	dwReserved1 uint32
	dwIntVersion uint32
	hProv uintptr
	DigestAlgorithm CRYPT_ALGORITHM_IDENTIFIER
	dwFlags uint32
	dwEncodingType uint32
	dwReserved2 uint32
	fdwCAPISettings uint32
	fdwSecuritySettings uint32
	dwIndex uint32
	dwUnionChoice uint32
	Anonymous _Anonymous_e__Union
	pClientData uintptr
}

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

  CRYPT_ALGORITHM_IDENTIFIER = record
    pszObjId: Pointer;
    Parameters: CRYPT_INTEGER_BLOB;
  end;

  SIP_SUBJECTINFO = record
    cbSize: DWORD;
    pgSubjectType: Pointer;
    hFile: Pointer;
    pwsFileName: Pointer;
    pwsDisplayName: Pointer;
    dwReserved1: DWORD;
    dwIntVersion: DWORD;
    hProv: NativeUInt;
    DigestAlgorithm: CRYPT_ALGORITHM_IDENTIFIER;
    dwFlags: DWORD;
    dwEncodingType: DWORD;
    dwReserved2: DWORD;
    fdwCAPISettings: DWORD;
    fdwSecuritySettings: DWORD;
    dwIndex: DWORD;
    dwUnionChoice: DWORD;
    Anonymous: _Anonymous_e__Union;
    pClientData: Pointer;
  end;

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

const CRYPT_ALGORITHM_IDENTIFIER = extern struct {
    pszObjId: ?*anyopaque,
    Parameters: CRYPT_INTEGER_BLOB,
};

const SIP_SUBJECTINFO = extern struct {
    cbSize: u32,
    pgSubjectType: ?*anyopaque,
    hFile: ?*anyopaque,
    pwsFileName: ?*anyopaque,
    pwsDisplayName: ?*anyopaque,
    dwReserved1: u32,
    dwIntVersion: u32,
    hProv: usize,
    DigestAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    dwFlags: u32,
    dwEncodingType: u32,
    dwReserved2: u32,
    fdwCAPISettings: u32,
    fdwSecuritySettings: u32,
    dwIndex: u32,
    dwUnionChoice: u32,
    Anonymous: _Anonymous_e__Union,
    pClientData: ?*anyopaque,
};

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

  CRYPT_ALGORITHM_IDENTIFIER {.bycopy.} = object
    pszObjId: pointer
    Parameters: CRYPT_INTEGER_BLOB

  SIP_SUBJECTINFO {.bycopy.} = object
    cbSize: uint32
    pgSubjectType: pointer
    hFile: pointer
    pwsFileName: pointer
    pwsDisplayName: pointer
    dwReserved1: uint32
    dwIntVersion: uint32
    hProv: uint
    DigestAlgorithm: CRYPT_ALGORITHM_IDENTIFIER
    dwFlags: uint32
    dwEncodingType: uint32
    dwReserved2: uint32
    fdwCAPISettings: uint32
    fdwSecuritySettings: uint32
    dwIndex: uint32
    dwUnionChoice: uint32
    Anonymous: _Anonymous_e__Union
    pClientData: pointer

struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct CRYPT_ALGORITHM_IDENTIFIER
{
    void* pszObjId;
    CRYPT_INTEGER_BLOB Parameters;
}

struct SIP_SUBJECTINFO
{
    uint cbSize;
    void* pgSubjectType;
    void* hFile;
    void* pwsFileName;
    void* pwsDisplayName;
    uint dwReserved1;
    uint dwIntVersion;
    size_t hProv;
    CRYPT_ALGORITHM_IDENTIFIER DigestAlgorithm;
    uint dwFlags;
    uint dwEncodingType;
    uint dwReserved2;
    uint fdwCAPISettings;
    uint fdwSecuritySettings;
    uint dwIndex;
    uint dwUnionChoice;
    _Anonymous_e__Union Anonymous;
    void* pClientData;
}