CMSG_CNG_CONTENT_DECRYPT_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_CNG_CONTENT_DECRYPT_INFO
{
    public uint cbSize;
    public CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
    public IntPtr pfnAlloc;
    public IntPtr pfnFree;
    public UIntPtr hNCryptKey;
    public IntPtr pbContentEncryptKey;
    public uint cbContentEncryptKey;
    public IntPtr hCNGContentEncryptKey;
    public IntPtr pbCNGContentEncryptKeyObject;
}

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_CNG_CONTENT_DECRYPT_INFO
    Public cbSize As UInteger
    Public ContentEncryptionAlgorithm As CRYPT_ALGORITHM_IDENTIFIER
    Public pfnAlloc As IntPtr
    Public pfnFree As IntPtr
    Public hNCryptKey As UIntPtr
    Public pbContentEncryptKey As IntPtr
    Public cbContentEncryptKey As UInteger
    Public hCNGContentEncryptKey As IntPtr
    Public pbCNGContentEncryptKeyObject 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_CNG_CONTENT_DECRYPT_INFO(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("ContentEncryptionAlgorithm", CRYPT_ALGORITHM_IDENTIFIER),
        ("pfnAlloc", ctypes.c_void_p),
        ("pfnFree", ctypes.c_void_p),
        ("hNCryptKey", ctypes.c_size_t),
        ("pbContentEncryptKey", ctypes.c_void_p),
        ("cbContentEncryptKey", wintypes.DWORD),
        ("hCNGContentEncryptKey", ctypes.c_void_p),
        ("pbCNGContentEncryptKeyObject", 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_CNG_CONTENT_DECRYPT_INFO {
    pub cbSize: u32,
    pub ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pub pfnAlloc: *mut core::ffi::c_void,
    pub pfnFree: *mut core::ffi::c_void,
    pub hNCryptKey: usize,
    pub pbContentEncryptKey: *mut core::ffi::c_void,
    pub cbContentEncryptKey: u32,
    pub hCNGContentEncryptKey: *mut core::ffi::c_void,
    pub pbCNGContentEncryptKeyObject: *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_CNG_CONTENT_DECRYPT_INFO struct {
	cbSize uint32
	ContentEncryptionAlgorithm CRYPT_ALGORITHM_IDENTIFIER
	pfnAlloc uintptr
	pfnFree uintptr
	hNCryptKey uintptr
	pbContentEncryptKey uintptr
	cbContentEncryptKey uint32
	hCNGContentEncryptKey uintptr
	pbCNGContentEncryptKeyObject uintptr
}

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

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

  CMSG_CNG_CONTENT_DECRYPT_INFO = record
    cbSize: DWORD;
    ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER;
    pfnAlloc: Pointer;
    pfnFree: Pointer;
    hNCryptKey: NativeUInt;
    pbContentEncryptKey: Pointer;
    cbContentEncryptKey: DWORD;
    hCNGContentEncryptKey: Pointer;
    pbCNGContentEncryptKeyObject: 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_CNG_CONTENT_DECRYPT_INFO = extern struct {
    cbSize: u32,
    ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pfnAlloc: ?*anyopaque,
    pfnFree: ?*anyopaque,
    hNCryptKey: usize,
    pbContentEncryptKey: ?*anyopaque,
    cbContentEncryptKey: u32,
    hCNGContentEncryptKey: ?*anyopaque,
    pbCNGContentEncryptKeyObject: ?*anyopaque,
};

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

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

  CMSG_CNG_CONTENT_DECRYPT_INFO {.bycopy.} = object
    cbSize: uint32
    ContentEncryptionAlgorithm: CRYPT_ALGORITHM_IDENTIFIER
    pfnAlloc: pointer
    pfnFree: pointer
    hNCryptKey: uint
    pbContentEncryptKey: pointer
    cbContentEncryptKey: uint32
    hCNGContentEncryptKey: pointer
    pbCNGContentEncryptKeyObject: pointer

struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct CRYPT_ALGORITHM_IDENTIFIER
{
    void* pszObjId;
    CRYPT_INTEGER_BLOB Parameters;
}

struct CMSG_CNG_CONTENT_DECRYPT_INFO
{
    uint cbSize;
    CRYPT_ALGORITHM_IDENTIFIER ContentEncryptionAlgorithm;
    void* pfnAlloc;
    void* pfnFree;
    size_t hNCryptKey;
    void* pbContentEncryptKey;
    uint cbContentEncryptKey;
    void* hCNGContentEncryptKey;
    void* pbCNGContentEncryptKeyObject;
}