KERB_EXTERNAL_TICKET

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct LSA_UNICODE_STRING
{
    public ushort Length;
    public ushort MaximumLength;
    public IntPtr Buffer;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct KERB_CRYPTO_KEY
{
    public int KeyType;
    public uint Length;
    public IntPtr Value;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct KERB_EXTERNAL_TICKET
{
    public IntPtr ServiceName;
    public IntPtr TargetName;
    public IntPtr ClientName;
    public LSA_UNICODE_STRING DomainName;
    public LSA_UNICODE_STRING TargetDomainName;
    public LSA_UNICODE_STRING AltTargetDomainName;
    public KERB_CRYPTO_KEY SessionKey;
    public uint TicketFlags;
    public uint Flags;
    public long KeyExpirationTime;
    public long StartTime;
    public long EndTime;
    public long RenewUntil;
    public long TimeSkew;
    public uint EncodedTicketSize;
    public IntPtr EncodedTicket;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure LSA_UNICODE_STRING
    Public Length As UShort
    Public MaximumLength As UShort
    Public Buffer As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure KERB_CRYPTO_KEY
    Public KeyType As Integer
    Public Length As UInteger
    Public Value As IntPtr
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure KERB_EXTERNAL_TICKET
    Public ServiceName As IntPtr
    Public TargetName As IntPtr
    Public ClientName As IntPtr
    Public DomainName As LSA_UNICODE_STRING
    Public TargetDomainName As LSA_UNICODE_STRING
    Public AltTargetDomainName As LSA_UNICODE_STRING
    Public SessionKey As KERB_CRYPTO_KEY
    Public TicketFlags As UInteger
    Public Flags As UInteger
    Public KeyExpirationTime As Long
    Public StartTime As Long
    Public EndTime As Long
    Public RenewUntil As Long
    Public TimeSkew As Long
    Public EncodedTicketSize As UInteger
    Public EncodedTicket As IntPtr
End Structure

import ctypes
from ctypes import wintypes

class LSA_UNICODE_STRING(ctypes.Structure):
    _fields_ = [
        ("Length", ctypes.c_ushort),
        ("MaximumLength", ctypes.c_ushort),
        ("Buffer", ctypes.c_void_p),
    ]

class KERB_CRYPTO_KEY(ctypes.Structure):
    _fields_ = [
        ("KeyType", ctypes.c_int),
        ("Length", wintypes.DWORD),
        ("Value", ctypes.c_void_p),
    ]

class KERB_EXTERNAL_TICKET(ctypes.Structure):
    _fields_ = [
        ("ServiceName", ctypes.c_void_p),
        ("TargetName", ctypes.c_void_p),
        ("ClientName", ctypes.c_void_p),
        ("DomainName", LSA_UNICODE_STRING),
        ("TargetDomainName", LSA_UNICODE_STRING),
        ("AltTargetDomainName", LSA_UNICODE_STRING),
        ("SessionKey", KERB_CRYPTO_KEY),
        ("TicketFlags", wintypes.DWORD),
        ("Flags", wintypes.DWORD),
        ("KeyExpirationTime", ctypes.c_longlong),
        ("StartTime", ctypes.c_longlong),
        ("EndTime", ctypes.c_longlong),
        ("RenewUntil", ctypes.c_longlong),
        ("TimeSkew", ctypes.c_longlong),
        ("EncodedTicketSize", wintypes.DWORD),
        ("EncodedTicket", ctypes.c_void_p),
    ]

#[repr(C)]
pub struct LSA_UNICODE_STRING {
    pub Length: u16,
    pub MaximumLength: u16,
    pub Buffer: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct KERB_CRYPTO_KEY {
    pub KeyType: i32,
    pub Length: u32,
    pub Value: *mut core::ffi::c_void,
}

#[repr(C)]
pub struct KERB_EXTERNAL_TICKET {
    pub ServiceName: *mut core::ffi::c_void,
    pub TargetName: *mut core::ffi::c_void,
    pub ClientName: *mut core::ffi::c_void,
    pub DomainName: LSA_UNICODE_STRING,
    pub TargetDomainName: LSA_UNICODE_STRING,
    pub AltTargetDomainName: LSA_UNICODE_STRING,
    pub SessionKey: KERB_CRYPTO_KEY,
    pub TicketFlags: u32,
    pub Flags: u32,
    pub KeyExpirationTime: i64,
    pub StartTime: i64,
    pub EndTime: i64,
    pub RenewUntil: i64,
    pub TimeSkew: i64,
    pub EncodedTicketSize: u32,
    pub EncodedTicket: *mut core::ffi::c_void,
}

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

type LSA_UNICODE_STRING struct {
	Length uint16
	MaximumLength uint16
	Buffer uintptr
}

type KERB_CRYPTO_KEY struct {
	KeyType int32
	Length uint32
	Value uintptr
}

type KERB_EXTERNAL_TICKET struct {
	ServiceName uintptr
	TargetName uintptr
	ClientName uintptr
	DomainName LSA_UNICODE_STRING
	TargetDomainName LSA_UNICODE_STRING
	AltTargetDomainName LSA_UNICODE_STRING
	SessionKey KERB_CRYPTO_KEY
	TicketFlags uint32
	Flags uint32
	KeyExpirationTime int64
	StartTime int64
	EndTime int64
	RenewUntil int64
	TimeSkew int64
	EncodedTicketSize uint32
	EncodedTicket uintptr
}

type
  LSA_UNICODE_STRING = record
    Length: Word;
    MaximumLength: Word;
    Buffer: Pointer;
  end;

  KERB_CRYPTO_KEY = record
    KeyType: Integer;
    Length: DWORD;
    Value: Pointer;
  end;

  KERB_EXTERNAL_TICKET = record
    ServiceName: Pointer;
    TargetName: Pointer;
    ClientName: Pointer;
    DomainName: LSA_UNICODE_STRING;
    TargetDomainName: LSA_UNICODE_STRING;
    AltTargetDomainName: LSA_UNICODE_STRING;
    SessionKey: KERB_CRYPTO_KEY;
    TicketFlags: DWORD;
    Flags: DWORD;
    KeyExpirationTime: Int64;
    StartTime: Int64;
    EndTime: Int64;
    RenewUntil: Int64;
    TimeSkew: Int64;
    EncodedTicketSize: DWORD;
    EncodedTicket: Pointer;
  end;

const LSA_UNICODE_STRING = extern struct {
    Length: u16,
    MaximumLength: u16,
    Buffer: ?*anyopaque,
};

const KERB_CRYPTO_KEY = extern struct {
    KeyType: i32,
    Length: u32,
    Value: ?*anyopaque,
};

const KERB_EXTERNAL_TICKET = extern struct {
    ServiceName: ?*anyopaque,
    TargetName: ?*anyopaque,
    ClientName: ?*anyopaque,
    DomainName: LSA_UNICODE_STRING,
    TargetDomainName: LSA_UNICODE_STRING,
    AltTargetDomainName: LSA_UNICODE_STRING,
    SessionKey: KERB_CRYPTO_KEY,
    TicketFlags: u32,
    Flags: u32,
    KeyExpirationTime: i64,
    StartTime: i64,
    EndTime: i64,
    RenewUntil: i64,
    TimeSkew: i64,
    EncodedTicketSize: u32,
    EncodedTicket: ?*anyopaque,
};

type
  LSA_UNICODE_STRING {.bycopy.} = object
    Length: uint16
    MaximumLength: uint16
    Buffer: pointer

  KERB_CRYPTO_KEY {.bycopy.} = object
    KeyType: int32
    Length: uint32
    Value: pointer

  KERB_EXTERNAL_TICKET {.bycopy.} = object
    ServiceName: pointer
    TargetName: pointer
    ClientName: pointer
    DomainName: LSA_UNICODE_STRING
    TargetDomainName: LSA_UNICODE_STRING
    AltTargetDomainName: LSA_UNICODE_STRING
    SessionKey: KERB_CRYPTO_KEY
    TicketFlags: uint32
    Flags: uint32
    KeyExpirationTime: int64
    StartTime: int64
    EndTime: int64
    RenewUntil: int64
    TimeSkew: int64
    EncodedTicketSize: uint32
    EncodedTicket: pointer

struct LSA_UNICODE_STRING
{
    ushort Length;
    ushort MaximumLength;
    void* Buffer;
}

struct KERB_CRYPTO_KEY
{
    int KeyType;
    uint Length;
    void* Value;
}

struct KERB_EXTERNAL_TICKET
{
    void* ServiceName;
    void* TargetName;
    void* ClientName;
    LSA_UNICODE_STRING DomainName;
    LSA_UNICODE_STRING TargetDomainName;
    LSA_UNICODE_STRING AltTargetDomainName;
    KERB_CRYPTO_KEY SessionKey;
    uint TicketFlags;
    uint Flags;
    long KeyExpirationTime;
    long StartTime;
    long EndTime;
    long RenewUntil;
    long TimeSkew;
    uint EncodedTicketSize;
    void* EncodedTicket;
}