CMSG_SIGNER_ENCODE_INFO

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 CMSG_SIGNER_ENCODE_INFO
{
    public uint cbSize;
    public IntPtr pCertInfo;
    public _Anonymous_e__Union Anonymous;
    public uint dwKeySpec;
    public CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
    public IntPtr pvHashAuxInfo;
    public uint cAuthAttr;
    public IntPtr rgAuthAttr;
    public uint cUnauthAttr;
    public IntPtr rgUnauthAttr;
}

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 CMSG_SIGNER_ENCODE_INFO
    Public cbSize As UInteger
    Public pCertInfo As IntPtr
    Public Anonymous As _Anonymous_e__Union
    Public dwKeySpec As UInteger
    Public HashAlgorithm As CRYPT_ALGORITHM_IDENTIFIER
    Public pvHashAuxInfo As IntPtr
    Public cAuthAttr As UInteger
    Public rgAuthAttr As IntPtr
    Public cUnauthAttr As UInteger
    Public rgUnauthAttr 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 CMSG_SIGNER_ENCODE_INFO(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("pCertInfo", ctypes.c_void_p),
        ("Anonymous", _Anonymous_e__Union),
        ("dwKeySpec", wintypes.DWORD),
        ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER),
        ("pvHashAuxInfo", ctypes.c_void_p),
        ("cAuthAttr", wintypes.DWORD),
        ("rgAuthAttr", ctypes.c_void_p),
        ("cUnauthAttr", wintypes.DWORD),
        ("rgUnauthAttr", 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 CMSG_SIGNER_ENCODE_INFO {
    pub cbSize: u32,
    pub pCertInfo: *mut core::ffi::c_void,
    pub Anonymous: _Anonymous_e__Union,
    pub dwKeySpec: u32,
    pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pub pvHashAuxInfo: *mut core::ffi::c_void,
    pub cAuthAttr: u32,
    pub rgAuthAttr: *mut core::ffi::c_void,
    pub cUnauthAttr: u32,
    pub rgUnauthAttr: *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 CMSG_SIGNER_ENCODE_INFO struct {
	cbSize uint32
	pCertInfo uintptr
	Anonymous _Anonymous_e__Union
	dwKeySpec uint32
	HashAlgorithm CRYPT_ALGORITHM_IDENTIFIER
	pvHashAuxInfo uintptr
	cAuthAttr uint32
	rgAuthAttr uintptr
	cUnauthAttr uint32
	rgUnauthAttr uintptr
}

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

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

  CMSG_SIGNER_ENCODE_INFO = record
    cbSize: DWORD;
    pCertInfo: Pointer;
    Anonymous: _Anonymous_e__Union;
    dwKeySpec: DWORD;
    HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER;
    pvHashAuxInfo: Pointer;
    cAuthAttr: DWORD;
    rgAuthAttr: Pointer;
    cUnauthAttr: DWORD;
    rgUnauthAttr: 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 CMSG_SIGNER_ENCODE_INFO = extern struct {
    cbSize: u32,
    pCertInfo: ?*anyopaque,
    Anonymous: _Anonymous_e__Union,
    dwKeySpec: u32,
    HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo: ?*anyopaque,
    cAuthAttr: u32,
    rgAuthAttr: ?*anyopaque,
    cUnauthAttr: u32,
    rgUnauthAttr: ?*anyopaque,
};

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

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

  CMSG_SIGNER_ENCODE_INFO {.bycopy.} = object
    cbSize: uint32
    pCertInfo: pointer
    Anonymous: _Anonymous_e__Union
    dwKeySpec: uint32
    HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER
    pvHashAuxInfo: pointer
    cAuthAttr: uint32
    rgAuthAttr: pointer
    cUnauthAttr: uint32
    rgUnauthAttr: pointer

struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct CRYPT_ALGORITHM_IDENTIFIER
{
    void* pszObjId;
    CRYPT_INTEGER_BLOB Parameters;
}

struct CMSG_SIGNER_ENCODE_INFO
{
    uint cbSize;
    void* pCertInfo;
    _Anonymous_e__Union Anonymous;
    uint dwKeySpec;
    CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
    void* pvHashAuxInfo;
    uint cAuthAttr;
    void* rgAuthAttr;
    uint cUnauthAttr;
    void* rgUnauthAttr;
}