BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct BCRYPT_INTERFACE_VERSION
{
    public ushort MajorVersion;
    public ushort MinorVersion;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE
{
    public BCRYPT_INTERFACE_VERSION Version;
    public IntPtr OpenAlgorithmProvider;
    public IntPtr GetProperty;
    public IntPtr SetProperty;
    public IntPtr CloseAlgorithmProvider;
    public IntPtr GenerateKeyPair;
    public IntPtr FinalizeKeyPair;
    public IntPtr Encrypt;
    public IntPtr Decrypt;
    public IntPtr ImportKeyPair;
    public IntPtr ExportKey;
    public IntPtr DestroyKey;
    public IntPtr SignHash;
    public IntPtr VerifySignature;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure BCRYPT_INTERFACE_VERSION
    Public MajorVersion As UShort
    Public MinorVersion As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE
    Public Version As BCRYPT_INTERFACE_VERSION
    Public OpenAlgorithmProvider As IntPtr
    Public GetProperty As IntPtr
    Public SetProperty As IntPtr
    Public CloseAlgorithmProvider As IntPtr
    Public GenerateKeyPair As IntPtr
    Public FinalizeKeyPair As IntPtr
    Public Encrypt As IntPtr
    Public Decrypt As IntPtr
    Public ImportKeyPair As IntPtr
    Public ExportKey As IntPtr
    Public DestroyKey As IntPtr
    Public SignHash As IntPtr
    Public VerifySignature As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class BCRYPT_INTERFACE_VERSION(ctypes.Structure):
    _fields_ = [
        ("MajorVersion", ctypes.c_ushort),
        ("MinorVersion", ctypes.c_ushort),
    ]

class BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE(ctypes.Structure):
    _fields_ = [
        ("Version", BCRYPT_INTERFACE_VERSION),
        ("OpenAlgorithmProvider", ctypes.c_void_p),
        ("GetProperty", ctypes.c_void_p),
        ("SetProperty", ctypes.c_void_p),
        ("CloseAlgorithmProvider", ctypes.c_void_p),
        ("GenerateKeyPair", ctypes.c_void_p),
        ("FinalizeKeyPair", ctypes.c_void_p),
        ("Encrypt", ctypes.c_void_p),
        ("Decrypt", ctypes.c_void_p),
        ("ImportKeyPair", ctypes.c_void_p),
        ("ExportKey", ctypes.c_void_p),
        ("DestroyKey", ctypes.c_void_p),
        ("SignHash", ctypes.c_void_p),
        ("VerifySignature", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct BCRYPT_INTERFACE_VERSION {
    pub MajorVersion: u16,
    pub MinorVersion: u16,
}

#[repr(C)]
pub struct BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE {
    pub Version: BCRYPT_INTERFACE_VERSION,
    pub OpenAlgorithmProvider: *mut core::ffi::c_void,
    pub GetProperty: *mut core::ffi::c_void,
    pub SetProperty: *mut core::ffi::c_void,
    pub CloseAlgorithmProvider: *mut core::ffi::c_void,
    pub GenerateKeyPair: *mut core::ffi::c_void,
    pub FinalizeKeyPair: *mut core::ffi::c_void,
    pub Encrypt: *mut core::ffi::c_void,
    pub Decrypt: *mut core::ffi::c_void,
    pub ImportKeyPair: *mut core::ffi::c_void,
    pub ExportKey: *mut core::ffi::c_void,
    pub DestroyKey: *mut core::ffi::c_void,
    pub SignHash: *mut core::ffi::c_void,
    pub VerifySignature: *mut core::ffi::c_void,
}

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

type BCRYPT_INTERFACE_VERSION struct {
	MajorVersion uint16
	MinorVersion uint16
}

type BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE struct {
	Version BCRYPT_INTERFACE_VERSION
	OpenAlgorithmProvider uintptr
	GetProperty uintptr
	SetProperty uintptr
	CloseAlgorithmProvider uintptr
	GenerateKeyPair uintptr
	FinalizeKeyPair uintptr
	Encrypt uintptr
	Decrypt uintptr
	ImportKeyPair uintptr
	ExportKey uintptr
	DestroyKey uintptr
	SignHash uintptr
	VerifySignature uintptr
}

type
  BCRYPT_INTERFACE_VERSION = record
    MajorVersion: Word;
    MinorVersion: Word;
  end;

  BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE = record
    Version: BCRYPT_INTERFACE_VERSION;
    OpenAlgorithmProvider: Pointer;
    GetProperty: Pointer;
    SetProperty: Pointer;
    CloseAlgorithmProvider: Pointer;
    GenerateKeyPair: Pointer;
    FinalizeKeyPair: Pointer;
    Encrypt: Pointer;
    Decrypt: Pointer;
    ImportKeyPair: Pointer;
    ExportKey: Pointer;
    DestroyKey: Pointer;
    SignHash: Pointer;
    VerifySignature: Pointer;
  end;

const BCRYPT_INTERFACE_VERSION = extern struct {
    MajorVersion: u16,
    MinorVersion: u16,
};

const BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE = extern struct {
    Version: BCRYPT_INTERFACE_VERSION,
    OpenAlgorithmProvider: ?*anyopaque,
    GetProperty: ?*anyopaque,
    SetProperty: ?*anyopaque,
    CloseAlgorithmProvider: ?*anyopaque,
    GenerateKeyPair: ?*anyopaque,
    FinalizeKeyPair: ?*anyopaque,
    Encrypt: ?*anyopaque,
    Decrypt: ?*anyopaque,
    ImportKeyPair: ?*anyopaque,
    ExportKey: ?*anyopaque,
    DestroyKey: ?*anyopaque,
    SignHash: ?*anyopaque,
    VerifySignature: ?*anyopaque,
};

type
  BCRYPT_INTERFACE_VERSION {.bycopy.} = object
    MajorVersion: uint16
    MinorVersion: uint16

  BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE {.bycopy.} = object
    Version: BCRYPT_INTERFACE_VERSION
    OpenAlgorithmProvider: pointer
    GetProperty: pointer
    SetProperty: pointer
    CloseAlgorithmProvider: pointer
    GenerateKeyPair: pointer
    FinalizeKeyPair: pointer
    Encrypt: pointer
    Decrypt: pointer
    ImportKeyPair: pointer
    ExportKey: pointer
    DestroyKey: pointer
    SignHash: pointer
    VerifySignature: pointer

struct BCRYPT_INTERFACE_VERSION
{
    ushort MajorVersion;
    ushort MinorVersion;
}

struct BCRYPT_ASYMMETRIC_ENCRYPTION_FUNCTION_TABLE
{
    BCRYPT_INTERFACE_VERSION Version;
    void* OpenAlgorithmProvider;
    void* GetProperty;
    void* SetProperty;
    void* CloseAlgorithmProvider;
    void* GenerateKeyPair;
    void* FinalizeKeyPair;
    void* Encrypt;
    void* Decrypt;
    void* ImportKeyPair;
    void* ExportKey;
    void* DestroyKey;
    void* SignHash;
    void* VerifySignature;
}