Win32 API 日本語リファレンス
ホーム › Security.Authentication.Identity › SECPKG_CREDENTIAL

SECPKG_CREDENTIAL

構造体
📘 Microsoft Learn (日本語) · English
サイズx64: 88 バイト / x86: 80 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド型サイズx64x86説明
VersionULONGLONG8+0+0本構造体のバージョン番号を示す64ビット値。
cbHeaderLengthWORD2+8+8構造体ヘッダー部の長さ(バイト数)。
cbStructureLengthDWORD4+12+12構造体全体の長さ(バイト数)。
ClientProcessDWORD4+16+16資格情報を供給したクライアントプロセスのID。
ClientThreadDWORD4+20+20資格情報を供給したクライアントスレッドのID。
LogonIdLUID8+24+24資格情報が属するログオンセッションを識別するLUID。
ClientTokenHANDLE8/4+32+32クライアントのアクセストークンを参照するハンドル。
SessionIdDWORD4+40+36クライアントのターミナルサービスセッションID。
ModifiedIdLUID8+44+40資格情報が最後に変更されたログオンセッションを示すLUID。
fCredentialsDWORD4+52+48資格情報の利用方向(インバウンド/アウトバウンド)を示すビットフラグ。
FlagsDWORD4+56+52資格情報の特性を示すビットフラグ。
PrincipalNameSECPKG_BYTE_VECTOR8+60+56プリンシパル名データの位置と長さを示すSECPKG_BYTE_VECTOR。
PackageListSECPKG_BYTE_VECTOR8+68+64許可パッケージ一覧データの位置と長さを示すSECPKG_BYTE_VECTOR。
MarshaledSuppliedCredsSECPKG_BYTE_VECTOR8+76+72マーシャリングされた供給資格情報の位置と長さを示すSECPKG_BYTE_VECTOR。

各言語での定義

#include <windows.h>

// LUID  (x64 8 / x86 8 バイト)
typedef struct LUID {
    DWORD LowPart;
    INT HighPart;
} LUID;

// SECPKG_BYTE_VECTOR  (x64 8 / x86 8 バイト)
typedef struct SECPKG_BYTE_VECTOR {
    DWORD ByteArrayOffset;
    WORD ByteArrayLength;
} SECPKG_BYTE_VECTOR;

// SECPKG_CREDENTIAL  (x64 88 / x86 80 バイト)
typedef struct SECPKG_CREDENTIAL {
    ULONGLONG Version;
    WORD cbHeaderLength;
    DWORD cbStructureLength;
    DWORD ClientProcess;
    DWORD ClientThread;
    LUID LogonId;
    HANDLE ClientToken;
    DWORD SessionId;
    LUID ModifiedId;
    DWORD fCredentials;
    DWORD Flags;
    SECPKG_BYTE_VECTOR PrincipalName;
    SECPKG_BYTE_VECTOR PackageList;
    SECPKG_BYTE_VECTOR MarshaledSuppliedCreds;
} SECPKG_CREDENTIAL;
using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct LUID
{
    public uint LowPart;
    public int HighPart;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SECPKG_BYTE_VECTOR
{
    public uint ByteArrayOffset;
    public ushort ByteArrayLength;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct SECPKG_CREDENTIAL
{
    public ulong Version;
    public ushort cbHeaderLength;
    public uint cbStructureLength;
    public uint ClientProcess;
    public uint ClientThread;
    public LUID LogonId;
    public IntPtr ClientToken;
    public uint SessionId;
    public LUID ModifiedId;
    public uint fCredentials;
    public uint Flags;
    public SECPKG_BYTE_VECTOR PrincipalName;
    public SECPKG_BYTE_VECTOR PackageList;
    public SECPKG_BYTE_VECTOR MarshaledSuppliedCreds;
}
Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure LUID
    Public LowPart As UInteger
    Public HighPart As Integer
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SECPKG_BYTE_VECTOR
    Public ByteArrayOffset As UInteger
    Public ByteArrayLength As UShort
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure SECPKG_CREDENTIAL
    Public Version As ULong
    Public cbHeaderLength As UShort
    Public cbStructureLength As UInteger
    Public ClientProcess As UInteger
    Public ClientThread As UInteger
    Public LogonId As LUID
    Public ClientToken As IntPtr
    Public SessionId As UInteger
    Public ModifiedId As LUID
    Public fCredentials As UInteger
    Public Flags As UInteger
    Public PrincipalName As SECPKG_BYTE_VECTOR
    Public PackageList As SECPKG_BYTE_VECTOR
    Public MarshaledSuppliedCreds As SECPKG_BYTE_VECTOR
End Structure
import ctypes
from ctypes import wintypes

class LUID(ctypes.Structure):
    _fields_ = [
        ("LowPart", wintypes.DWORD),
        ("HighPart", ctypes.c_int),
    ]

class SECPKG_BYTE_VECTOR(ctypes.Structure):
    _fields_ = [
        ("ByteArrayOffset", wintypes.DWORD),
        ("ByteArrayLength", ctypes.c_ushort),
    ]

class SECPKG_CREDENTIAL(ctypes.Structure):
    _fields_ = [
        ("Version", ctypes.c_ulonglong),
        ("cbHeaderLength", ctypes.c_ushort),
        ("cbStructureLength", wintypes.DWORD),
        ("ClientProcess", wintypes.DWORD),
        ("ClientThread", wintypes.DWORD),
        ("LogonId", LUID),
        ("ClientToken", ctypes.c_void_p),
        ("SessionId", wintypes.DWORD),
        ("ModifiedId", LUID),
        ("fCredentials", wintypes.DWORD),
        ("Flags", wintypes.DWORD),
        ("PrincipalName", SECPKG_BYTE_VECTOR),
        ("PackageList", SECPKG_BYTE_VECTOR),
        ("MarshaledSuppliedCreds", SECPKG_BYTE_VECTOR),
    ]
#[repr(C)]
pub struct LUID {
    pub LowPart: u32,
    pub HighPart: i32,
}

#[repr(C)]
pub struct SECPKG_BYTE_VECTOR {
    pub ByteArrayOffset: u32,
    pub ByteArrayLength: u16,
}

#[repr(C)]
pub struct SECPKG_CREDENTIAL {
    pub Version: u64,
    pub cbHeaderLength: u16,
    pub cbStructureLength: u32,
    pub ClientProcess: u32,
    pub ClientThread: u32,
    pub LogonId: LUID,
    pub ClientToken: *mut core::ffi::c_void,
    pub SessionId: u32,
    pub ModifiedId: LUID,
    pub fCredentials: u32,
    pub Flags: u32,
    pub PrincipalName: SECPKG_BYTE_VECTOR,
    pub PackageList: SECPKG_BYTE_VECTOR,
    pub MarshaledSuppliedCreds: SECPKG_BYTE_VECTOR,
}
import "golang.org/x/sys/windows"

type LUID struct {
	LowPart uint32
	HighPart int32
}

type SECPKG_BYTE_VECTOR struct {
	ByteArrayOffset uint32
	ByteArrayLength uint16
}

type SECPKG_CREDENTIAL struct {
	Version uint64
	cbHeaderLength uint16
	cbStructureLength uint32
	ClientProcess uint32
	ClientThread uint32
	LogonId LUID
	ClientToken uintptr
	SessionId uint32
	ModifiedId LUID
	fCredentials uint32
	Flags uint32
	PrincipalName SECPKG_BYTE_VECTOR
	PackageList SECPKG_BYTE_VECTOR
	MarshaledSuppliedCreds SECPKG_BYTE_VECTOR
}
type
  LUID = record
    LowPart: DWORD;
    HighPart: Integer;
  end;

  SECPKG_BYTE_VECTOR = record
    ByteArrayOffset: DWORD;
    ByteArrayLength: Word;
  end;

  SECPKG_CREDENTIAL = record
    Version: UInt64;
    cbHeaderLength: Word;
    cbStructureLength: DWORD;
    ClientProcess: DWORD;
    ClientThread: DWORD;
    LogonId: LUID;
    ClientToken: Pointer;
    SessionId: DWORD;
    ModifiedId: LUID;
    fCredentials: DWORD;
    Flags: DWORD;
    PrincipalName: SECPKG_BYTE_VECTOR;
    PackageList: SECPKG_BYTE_VECTOR;
    MarshaledSuppliedCreds: SECPKG_BYTE_VECTOR;
  end;
const LUID = extern struct {
    LowPart: u32,
    HighPart: i32,
};

const SECPKG_BYTE_VECTOR = extern struct {
    ByteArrayOffset: u32,
    ByteArrayLength: u16,
};

const SECPKG_CREDENTIAL = extern struct {
    Version: u64,
    cbHeaderLength: u16,
    cbStructureLength: u32,
    ClientProcess: u32,
    ClientThread: u32,
    LogonId: LUID,
    ClientToken: ?*anyopaque,
    SessionId: u32,
    ModifiedId: LUID,
    fCredentials: u32,
    Flags: u32,
    PrincipalName: SECPKG_BYTE_VECTOR,
    PackageList: SECPKG_BYTE_VECTOR,
    MarshaledSuppliedCreds: SECPKG_BYTE_VECTOR,
};
type
  LUID {.bycopy.} = object
    LowPart: uint32
    HighPart: int32

  SECPKG_BYTE_VECTOR {.bycopy.} = object
    ByteArrayOffset: uint32
    ByteArrayLength: uint16

  SECPKG_CREDENTIAL {.bycopy.} = object
    Version: uint64
    cbHeaderLength: uint16
    cbStructureLength: uint32
    ClientProcess: uint32
    ClientThread: uint32
    LogonId: LUID
    ClientToken: pointer
    SessionId: uint32
    ModifiedId: LUID
    fCredentials: uint32
    Flags: uint32
    PrincipalName: SECPKG_BYTE_VECTOR
    PackageList: SECPKG_BYTE_VECTOR
    MarshaledSuppliedCreds: SECPKG_BYTE_VECTOR
struct LUID
{
    uint LowPart;
    int HighPart;
}

struct SECPKG_BYTE_VECTOR
{
    uint ByteArrayOffset;
    ushort ByteArrayLength;
}

struct SECPKG_CREDENTIAL
{
    ulong Version;
    ushort cbHeaderLength;
    uint cbStructureLength;
    uint ClientProcess;
    uint ClientThread;
    LUID LogonId;
    void* ClientToken;
    uint SessionId;
    LUID ModifiedId;
    uint fCredentials;
    uint Flags;
    SECPKG_BYTE_VECTOR PrincipalName;
    SECPKG_BYTE_VECTOR PackageList;
    SECPKG_BYTE_VECTOR MarshaledSuppliedCreds;
}

HSP用 定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; SECPKG_CREDENTIAL サイズ: 80 バイト(x86)
dim st, 20    ; 4byte整数×20(構造体サイズ 80 / 4 切り上げ)
; Version : ULONGLONG (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; cbHeaderLength : WORD (+8, 2byte)  wpoke st,8,値  /  値 = wpeek(st,8)
; cbStructureLength : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; ClientProcess : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; ClientThread : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; LogonId : LUID (+24, 8byte)  varptr(st)+24 を基点に操作(8byte:入れ子/配列)
; ClientToken : HANDLE (+32, 4byte)  st.8 = 値  /  値 = st.8   (lpoke/lpeek も可)
; SessionId : DWORD (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; ModifiedId : LUID (+40, 8byte)  varptr(st)+40 を基点に操作(8byte:入れ子/配列)
; fCredentials : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; Flags : DWORD (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; PrincipalName : SECPKG_BYTE_VECTOR (+56, 8byte)  varptr(st)+56 を基点に操作(8byte:入れ子/配列)
; PackageList : SECPKG_BYTE_VECTOR (+64, 8byte)  varptr(st)+64 を基点に操作(8byte:入れ子/配列)
; MarshaledSuppliedCreds : SECPKG_BYTE_VECTOR (+72, 8byte)  varptr(st)+72 を基点に操作(8byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; SECPKG_CREDENTIAL サイズ: 88 バイト(x64)
dim st, 22    ; 4byte整数×22(構造体サイズ 88 / 4 切り上げ)
; Version : ULONGLONG (+0, 8byte)  qpoke st,0,値 / qpeek(st,0)  ※IronHSPのみ。3.7/3.8は lpoke st,0,下位 : lpoke st,4,上位
; cbHeaderLength : WORD (+8, 2byte)  wpoke st,8,値  /  値 = wpeek(st,8)
; cbStructureLength : DWORD (+12, 4byte)  st.3 = 値  /  値 = st.3   (lpoke/lpeek も可)
; ClientProcess : DWORD (+16, 4byte)  st.4 = 値  /  値 = st.4   (lpoke/lpeek も可)
; ClientThread : DWORD (+20, 4byte)  st.5 = 値  /  値 = st.5   (lpoke/lpeek も可)
; LogonId : LUID (+24, 8byte)  varptr(st)+24 を基点に操作(8byte:入れ子/配列)
; ClientToken : HANDLE (+32, 8byte)  qpoke st,32,値 / qpeek(st,32)  ※IronHSPのみ。3.7/3.8は lpoke st,32,下位 : lpoke st,36,上位
; SessionId : DWORD (+40, 4byte)  st.10 = 値  /  値 = st.10   (lpoke/lpeek も可)
; ModifiedId : LUID (+44, 8byte)  varptr(st)+44 を基点に操作(8byte:入れ子/配列)
; fCredentials : DWORD (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; Flags : DWORD (+56, 4byte)  st.14 = 値  /  値 = st.14   (lpoke/lpeek も可)
; PrincipalName : SECPKG_BYTE_VECTOR (+60, 8byte)  varptr(st)+60 を基点に操作(8byte:入れ子/配列)
; PackageList : SECPKG_BYTE_VECTOR (+68, 8byte)  varptr(st)+68 を基点に操作(8byte:入れ子/配列)
; MarshaledSuppliedCreds : SECPKG_BYTE_VECTOR (+76, 8byte)  varptr(st)+76 を基点に操作(8byte:入れ子/配列)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global LUID
    #field int LowPart
    #field int HighPart
#endstruct

#defstruct global SECPKG_BYTE_VECTOR
    #field int ByteArrayOffset
    #field short ByteArrayLength
#endstruct

#defstruct global SECPKG_CREDENTIAL
    #field int64 Version
    #field short cbHeaderLength
    #field int cbStructureLength
    #field int ClientProcess
    #field int ClientThread
    #field LUID LogonId
    #field intptr ClientToken
    #field int SessionId
    #field LUID ModifiedId
    #field int fCredentials
    #field int Flags
    #field SECPKG_BYTE_VECTOR PrincipalName
    #field SECPKG_BYTE_VECTOR PackageList
    #field SECPKG_BYTE_VECTOR MarshaledSuppliedCreds
#endstruct

stdim st, SECPKG_CREDENTIAL        ; NSTRUCT 変数を確保
st->Version = 100
mes "Version=" + st->Version