ENCRYPTED_CREDENTIALW

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct FILETIME
{
    public uint dwLowDateTime;
    public uint dwHighDateTime;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct CREDENTIALW
{
    public uint Flags;
    public uint Type;
    public IntPtr TargetName;
    public IntPtr Comment;
    public FILETIME LastWritten;
    public uint CredentialBlobSize;
    public IntPtr CredentialBlob;
    public uint Persist;
    public uint AttributeCount;
    public IntPtr Attributes;
    public IntPtr TargetAlias;
    public IntPtr UserName;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct ENCRYPTED_CREDENTIALW
{
    public CREDENTIALW Cred;
    public uint ClearCredentialBlobSize;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure FILETIME
    Public dwLowDateTime As UInteger
    Public dwHighDateTime As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure CREDENTIALW
    Public Flags As UInteger
    Public Type As UInteger
    Public TargetName As IntPtr
    Public Comment As IntPtr
    Public LastWritten As FILETIME
    Public CredentialBlobSize As UInteger
    Public CredentialBlob As IntPtr
    Public Persist As UInteger
    Public AttributeCount As UInteger
    Public Attributes As IntPtr
    Public TargetAlias As IntPtr
    Public UserName As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure ENCRYPTED_CREDENTIALW
    Public Cred As CREDENTIALW
    Public ClearCredentialBlobSize As UInteger
End Structure

import ctypes
from ctypes import wintypes

class FILETIME(ctypes.Structure):
    _fields_ = [
        ("dwLowDateTime", wintypes.DWORD),
        ("dwHighDateTime", wintypes.DWORD),
    ]

class CREDENTIALW(ctypes.Structure):
    _fields_ = [
        ("Flags", wintypes.DWORD),
        ("Type", wintypes.DWORD),
        ("TargetName", ctypes.c_void_p),
        ("Comment", ctypes.c_void_p),
        ("LastWritten", FILETIME),
        ("CredentialBlobSize", wintypes.DWORD),
        ("CredentialBlob", ctypes.c_void_p),
        ("Persist", wintypes.DWORD),
        ("AttributeCount", wintypes.DWORD),
        ("Attributes", ctypes.c_void_p),
        ("TargetAlias", ctypes.c_void_p),
        ("UserName", ctypes.c_void_p),
    ]

class ENCRYPTED_CREDENTIALW(ctypes.Structure):
    _fields_ = [
        ("Cred", CREDENTIALW),
        ("ClearCredentialBlobSize", wintypes.DWORD),
    ]

#[repr(C)]
pub struct FILETIME {
    pub dwLowDateTime: u32,
    pub dwHighDateTime: u32,
}

#[repr(C)]
pub struct CREDENTIALW {
    pub Flags: u32,
    pub Type: u32,
    pub TargetName: *mut core::ffi::c_void,
    pub Comment: *mut core::ffi::c_void,
    pub LastWritten: FILETIME,
    pub CredentialBlobSize: u32,
    pub CredentialBlob: *mut core::ffi::c_void,
    pub Persist: u32,
    pub AttributeCount: u32,
    pub Attributes: *mut core::ffi::c_void,
    pub TargetAlias: *mut core::ffi::c_void,
    pub UserName: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct ENCRYPTED_CREDENTIALW {
    pub Cred: CREDENTIALW,
    pub ClearCredentialBlobSize: u32,
}

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

type FILETIME struct {
	dwLowDateTime uint32
	dwHighDateTime uint32
}

type CREDENTIALW struct {
	Flags uint32
	Type uint32
	TargetName uintptr
	Comment uintptr
	LastWritten FILETIME
	CredentialBlobSize uint32
	CredentialBlob uintptr
	Persist uint32
	AttributeCount uint32
	Attributes uintptr
	TargetAlias uintptr
	UserName uintptr
}

type ENCRYPTED_CREDENTIALW struct {
	Cred CREDENTIALW
	ClearCredentialBlobSize uint32
}

type
  FILETIME = record
    dwLowDateTime: DWORD;
    dwHighDateTime: DWORD;
  end;

  CREDENTIALW = record
    Flags: DWORD;
    Type: DWORD;
    TargetName: Pointer;
    Comment: Pointer;
    LastWritten: FILETIME;
    CredentialBlobSize: DWORD;
    CredentialBlob: Pointer;
    Persist: DWORD;
    AttributeCount: DWORD;
    Attributes: Pointer;
    TargetAlias: Pointer;
    UserName: Pointer;
  end;

  ENCRYPTED_CREDENTIALW = record
    Cred: CREDENTIALW;
    ClearCredentialBlobSize: DWORD;
  end;

const FILETIME = extern struct {
    dwLowDateTime: u32,
    dwHighDateTime: u32,
};

const CREDENTIALW = extern struct {
    Flags: u32,
    Type: u32,
    TargetName: ?*anyopaque,
    Comment: ?*anyopaque,
    LastWritten: FILETIME,
    CredentialBlobSize: u32,
    CredentialBlob: ?*anyopaque,
    Persist: u32,
    AttributeCount: u32,
    Attributes: ?*anyopaque,
    TargetAlias: ?*anyopaque,
    UserName: ?*anyopaque,
};

const ENCRYPTED_CREDENTIALW = extern struct {
    Cred: CREDENTIALW,
    ClearCredentialBlobSize: u32,
};

type
  FILETIME {.bycopy.} = object
    dwLowDateTime: uint32
    dwHighDateTime: uint32

  CREDENTIALW {.bycopy.} = object
    Flags: uint32
    Type: uint32
    TargetName: pointer
    Comment: pointer
    LastWritten: FILETIME
    CredentialBlobSize: uint32
    CredentialBlob: pointer
    Persist: uint32
    AttributeCount: uint32
    Attributes: pointer
    TargetAlias: pointer
    UserName: pointer

  ENCRYPTED_CREDENTIALW {.bycopy.} = object
    Cred: CREDENTIALW
    ClearCredentialBlobSize: uint32

struct FILETIME
{
    uint dwLowDateTime;
    uint dwHighDateTime;
}

struct CREDENTIALW
{
    uint Flags;
    uint Type;
    void* TargetName;
    void* Comment;
    FILETIME LastWritten;
    uint CredentialBlobSize;
    void* CredentialBlob;
    uint Persist;
    uint AttributeCount;
    void* Attributes;
    void* TargetAlias;
    void* UserName;
}

struct ENCRYPTED_CREDENTIALW
{
    CREDENTIALW Cred;
    uint ClearCredentialBlobSize;
}