Win32 API 日本語リファレンス
ホーム › Security.Cryptography › CRYPT_SIGN_MESSAGE_PARA

CRYPT_SIGN_MESSAGE_PARA

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

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

フィールド

フィールド型サイズx64x86説明
cbSizeDWORD4+0+0この構造体のサイズ(バイト単位)。
dwMsgEncodingTypeDWORD4+4+4メッセージのエンコード種別。
pSigningCertCERT_CONTEXT*8/4+8+8署名に使う証明書コンテキストへのポインタ。
HashAlgorithmCRYPT_ALGORITHM_IDENTIFIER24/12+16+12署名前のハッシュ計算に用いるアルゴリズム識別子。
pvHashAuxInfovoid*8/4+40+24ハッシュアルゴリズムの補助情報へのポインタ。NULL可。
cMsgCertDWORD4+48+28rgpMsgCert配列の要素数。
rgpMsgCertCERT_CONTEXT**8/4+56+32メッセージに含める証明書コンテキストポインタの配列へのポインタ。NULL可。
cMsgCrlDWORD4+64+36rgpMsgCrl配列の要素数。
rgpMsgCrlCRL_CONTEXT**8/4+72+40メッセージに含めるCRLコンテキストポインタの配列へのポインタ。NULL可。
cAuthAttrDWORD4+80+44rgAuthAttr配列の要素数。
rgAuthAttrCRYPT_ATTRIBUTE*8/4+88+48認証付き属性の配列へのポインタ。NULL可。
cUnauthAttrDWORD4+96+52rgUnauthAttr配列の要素数。
rgUnauthAttrCRYPT_ATTRIBUTE*8/4+104+56非認証属性の配列へのポインタ。NULL可。
dwFlagsDWORD4+112+60署名処理を制御するフラグ。
dwInnerContentTypeDWORD4+116+64署名対象の内部コンテンツ種別。

各言語での定義

#include <windows.h>

// CRYPT_INTEGER_BLOB  (x64 16 / x86 8 バイト)
typedef struct CRYPT_INTEGER_BLOB {
    DWORD cbData;
    BYTE* pbData;
} CRYPT_INTEGER_BLOB;

// CRYPT_ALGORITHM_IDENTIFIER  (x64 24 / x86 12 バイト)
typedef struct CRYPT_ALGORITHM_IDENTIFIER {
    LPSTR pszObjId;
    CRYPT_INTEGER_BLOB Parameters;
} CRYPT_ALGORITHM_IDENTIFIER;

// CRYPT_SIGN_MESSAGE_PARA  (x64 120 / x86 68 バイト)
typedef struct CRYPT_SIGN_MESSAGE_PARA {
    DWORD cbSize;
    DWORD dwMsgEncodingType;
    CERT_CONTEXT* pSigningCert;
    CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
    void* pvHashAuxInfo;
    DWORD cMsgCert;
    CERT_CONTEXT** rgpMsgCert;
    DWORD cMsgCrl;
    CRL_CONTEXT** rgpMsgCrl;
    DWORD cAuthAttr;
    CRYPT_ATTRIBUTE* rgAuthAttr;
    DWORD cUnauthAttr;
    CRYPT_ATTRIBUTE* rgUnauthAttr;
    DWORD dwFlags;
    DWORD dwInnerContentType;
} CRYPT_SIGN_MESSAGE_PARA;
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 CRYPT_SIGN_MESSAGE_PARA
{
    public uint cbSize;
    public uint dwMsgEncodingType;
    public IntPtr pSigningCert;
    public CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
    public IntPtr pvHashAuxInfo;
    public uint cMsgCert;
    public IntPtr rgpMsgCert;
    public uint cMsgCrl;
    public IntPtr rgpMsgCrl;
    public uint cAuthAttr;
    public IntPtr rgAuthAttr;
    public uint cUnauthAttr;
    public IntPtr rgUnauthAttr;
    public uint dwFlags;
    public uint dwInnerContentType;
}
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 CRYPT_SIGN_MESSAGE_PARA
    Public cbSize As UInteger
    Public dwMsgEncodingType As UInteger
    Public pSigningCert As IntPtr
    Public HashAlgorithm As CRYPT_ALGORITHM_IDENTIFIER
    Public pvHashAuxInfo As IntPtr
    Public cMsgCert As UInteger
    Public rgpMsgCert As IntPtr
    Public cMsgCrl As UInteger
    Public rgpMsgCrl As IntPtr
    Public cAuthAttr As UInteger
    Public rgAuthAttr As IntPtr
    Public cUnauthAttr As UInteger
    Public rgUnauthAttr As IntPtr
    Public dwFlags As UInteger
    Public dwInnerContentType As UInteger
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 CRYPT_SIGN_MESSAGE_PARA(ctypes.Structure):
    _fields_ = [
        ("cbSize", wintypes.DWORD),
        ("dwMsgEncodingType", wintypes.DWORD),
        ("pSigningCert", ctypes.c_void_p),
        ("HashAlgorithm", CRYPT_ALGORITHM_IDENTIFIER),
        ("pvHashAuxInfo", ctypes.c_void_p),
        ("cMsgCert", wintypes.DWORD),
        ("rgpMsgCert", ctypes.c_void_p),
        ("cMsgCrl", wintypes.DWORD),
        ("rgpMsgCrl", ctypes.c_void_p),
        ("cAuthAttr", wintypes.DWORD),
        ("rgAuthAttr", ctypes.c_void_p),
        ("cUnauthAttr", wintypes.DWORD),
        ("rgUnauthAttr", ctypes.c_void_p),
        ("dwFlags", wintypes.DWORD),
        ("dwInnerContentType", wintypes.DWORD),
    ]
#[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 CRYPT_SIGN_MESSAGE_PARA {
    pub cbSize: u32,
    pub dwMsgEncodingType: u32,
    pub pSigningCert: *mut core::ffi::c_void,
    pub HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pub pvHashAuxInfo: *mut core::ffi::c_void,
    pub cMsgCert: u32,
    pub rgpMsgCert: *mut core::ffi::c_void,
    pub cMsgCrl: u32,
    pub rgpMsgCrl: *mut core::ffi::c_void,
    pub cAuthAttr: u32,
    pub rgAuthAttr: *mut core::ffi::c_void,
    pub cUnauthAttr: u32,
    pub rgUnauthAttr: *mut core::ffi::c_void,
    pub dwFlags: u32,
    pub dwInnerContentType: u32,
}
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 CRYPT_SIGN_MESSAGE_PARA struct {
	cbSize uint32
	dwMsgEncodingType uint32
	pSigningCert uintptr
	HashAlgorithm CRYPT_ALGORITHM_IDENTIFIER
	pvHashAuxInfo uintptr
	cMsgCert uint32
	rgpMsgCert uintptr
	cMsgCrl uint32
	rgpMsgCrl uintptr
	cAuthAttr uint32
	rgAuthAttr uintptr
	cUnauthAttr uint32
	rgUnauthAttr uintptr
	dwFlags uint32
	dwInnerContentType uint32
}
type
  CRYPT_INTEGER_BLOB = record
    cbData: DWORD;
    pbData: Pointer;
  end;

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

  CRYPT_SIGN_MESSAGE_PARA = record
    cbSize: DWORD;
    dwMsgEncodingType: DWORD;
    pSigningCert: Pointer;
    HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER;
    pvHashAuxInfo: Pointer;
    cMsgCert: DWORD;
    rgpMsgCert: Pointer;
    cMsgCrl: DWORD;
    rgpMsgCrl: Pointer;
    cAuthAttr: DWORD;
    rgAuthAttr: Pointer;
    cUnauthAttr: DWORD;
    rgUnauthAttr: Pointer;
    dwFlags: DWORD;
    dwInnerContentType: DWORD;
  end;
const CRYPT_INTEGER_BLOB = extern struct {
    cbData: u32,
    pbData: ?*anyopaque,
};

const CRYPT_ALGORITHM_IDENTIFIER = extern struct {
    pszObjId: ?*anyopaque,
    Parameters: CRYPT_INTEGER_BLOB,
};

const CRYPT_SIGN_MESSAGE_PARA = extern struct {
    cbSize: u32,
    dwMsgEncodingType: u32,
    pSigningCert: ?*anyopaque,
    HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER,
    pvHashAuxInfo: ?*anyopaque,
    cMsgCert: u32,
    rgpMsgCert: ?*anyopaque,
    cMsgCrl: u32,
    rgpMsgCrl: ?*anyopaque,
    cAuthAttr: u32,
    rgAuthAttr: ?*anyopaque,
    cUnauthAttr: u32,
    rgUnauthAttr: ?*anyopaque,
    dwFlags: u32,
    dwInnerContentType: u32,
};
type
  CRYPT_INTEGER_BLOB {.bycopy.} = object
    cbData: uint32
    pbData: pointer

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

  CRYPT_SIGN_MESSAGE_PARA {.bycopy.} = object
    cbSize: uint32
    dwMsgEncodingType: uint32
    pSigningCert: pointer
    HashAlgorithm: CRYPT_ALGORITHM_IDENTIFIER
    pvHashAuxInfo: pointer
    cMsgCert: uint32
    rgpMsgCert: pointer
    cMsgCrl: uint32
    rgpMsgCrl: pointer
    cAuthAttr: uint32
    rgAuthAttr: pointer
    cUnauthAttr: uint32
    rgUnauthAttr: pointer
    dwFlags: uint32
    dwInnerContentType: uint32
struct CRYPT_INTEGER_BLOB
{
    uint cbData;
    void* pbData;
}

struct CRYPT_ALGORITHM_IDENTIFIER
{
    void* pszObjId;
    CRYPT_INTEGER_BLOB Parameters;
}

struct CRYPT_SIGN_MESSAGE_PARA
{
    uint cbSize;
    uint dwMsgEncodingType;
    void* pSigningCert;
    CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm;
    void* pvHashAuxInfo;
    uint cMsgCert;
    void* rgpMsgCert;
    uint cMsgCrl;
    void* rgpMsgCrl;
    uint cAuthAttr;
    void* rgAuthAttr;
    uint cUnauthAttr;
    void* rgUnauthAttr;
    uint dwFlags;
    uint dwInnerContentType;
}

HSP用 定義

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

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; CRYPT_SIGN_MESSAGE_PARA サイズ: 68 バイト(x86)
dim st, 17    ; 4byte整数×17(構造体サイズ 68 / 4 切り上げ)
; cbSize : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; dwMsgEncodingType : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; pSigningCert : CERT_CONTEXT* (+8, 4byte)  varptr(st)+8 を基点に操作(4byte:入れ子/配列)
; HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER (+12, 12byte)  varptr(st)+12 を基点に操作(12byte:入れ子/配列)
; pvHashAuxInfo : void* (+24, 4byte)  st.6 = 値  /  値 = st.6   (lpoke/lpeek も可)
; cMsgCert : DWORD (+28, 4byte)  st.7 = 値  /  値 = st.7   (lpoke/lpeek も可)
; rgpMsgCert : CERT_CONTEXT** (+32, 4byte)  varptr(st)+32 を基点に操作(4byte:入れ子/配列)
; cMsgCrl : DWORD (+36, 4byte)  st.9 = 値  /  値 = st.9   (lpoke/lpeek も可)
; rgpMsgCrl : CRL_CONTEXT** (+40, 4byte)  varptr(st)+40 を基点に操作(4byte:入れ子/配列)
; cAuthAttr : DWORD (+44, 4byte)  st.11 = 値  /  値 = st.11   (lpoke/lpeek も可)
; rgAuthAttr : CRYPT_ATTRIBUTE* (+48, 4byte)  varptr(st)+48 を基点に操作(4byte:入れ子/配列)
; cUnauthAttr : DWORD (+52, 4byte)  st.13 = 値  /  値 = st.13   (lpoke/lpeek も可)
; rgUnauthAttr : CRYPT_ATTRIBUTE* (+56, 4byte)  varptr(st)+56 を基点に操作(4byte:入れ子/配列)
; dwFlags : DWORD (+60, 4byte)  st.15 = 値  /  値 = st.15   (lpoke/lpeek も可)
; dwInnerContentType : DWORD (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; CRYPT_SIGN_MESSAGE_PARA サイズ: 120 バイト(x64)
dim st, 30    ; 4byte整数×30(構造体サイズ 120 / 4 切り上げ)
; cbSize : DWORD (+0, 4byte)  st.0 = 値  /  値 = st.0   (lpoke/lpeek も可)
; dwMsgEncodingType : DWORD (+4, 4byte)  st.1 = 値  /  値 = st.1   (lpoke/lpeek も可)
; pSigningCert : CERT_CONTEXT* (+8, 8byte)  varptr(st)+8 を基点に操作(8byte:入れ子/配列)
; HashAlgorithm : CRYPT_ALGORITHM_IDENTIFIER (+16, 24byte)  varptr(st)+16 を基点に操作(24byte:入れ子/配列)
; pvHashAuxInfo : void* (+40, 8byte)  qpoke st,40,値 / qpeek(st,40)  ※IronHSPのみ。3.7/3.8は lpoke st,40,下位 : lpoke st,44,上位
; cMsgCert : DWORD (+48, 4byte)  st.12 = 値  /  値 = st.12   (lpoke/lpeek も可)
; rgpMsgCert : CERT_CONTEXT** (+56, 8byte)  varptr(st)+56 を基点に操作(8byte:入れ子/配列)
; cMsgCrl : DWORD (+64, 4byte)  st.16 = 値  /  値 = st.16   (lpoke/lpeek も可)
; rgpMsgCrl : CRL_CONTEXT** (+72, 8byte)  varptr(st)+72 を基点に操作(8byte:入れ子/配列)
; cAuthAttr : DWORD (+80, 4byte)  st.20 = 値  /  値 = st.20   (lpoke/lpeek も可)
; rgAuthAttr : CRYPT_ATTRIBUTE* (+88, 8byte)  varptr(st)+88 を基点に操作(8byte:入れ子/配列)
; cUnauthAttr : DWORD (+96, 4byte)  st.24 = 値  /  値 = st.24   (lpoke/lpeek も可)
; rgUnauthAttr : CRYPT_ATTRIBUTE* (+104, 8byte)  varptr(st)+104 を基点に操作(8byte:入れ子/配列)
; dwFlags : DWORD (+112, 4byte)  st.28 = 値  /  値 = st.28   (lpoke/lpeek も可)
; dwInnerContentType : DWORD (+116, 4byte)  st.29 = 値  /  値 = st.29   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。
; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global CRYPT_INTEGER_BLOB
    #field int cbData
    #field intptr pbData
#endstruct

#defstruct global CRYPT_ALGORITHM_IDENTIFIER
    #field intptr pszObjId
    #field CRYPT_INTEGER_BLOB Parameters
#endstruct

#defstruct global CRYPT_SIGN_MESSAGE_PARA
    #field int cbSize
    #field int dwMsgEncodingType
    #field intptr pSigningCert
    #field CRYPT_ALGORITHM_IDENTIFIER HashAlgorithm
    #field intptr pvHashAuxInfo
    #field int cMsgCert
    #field intptr rgpMsgCert
    #field int cMsgCrl
    #field intptr rgpMsgCrl
    #field int cAuthAttr
    #field intptr rgAuthAttr
    #field int cUnauthAttr
    #field intptr rgUnauthAttr
    #field int dwFlags
    #field int dwInnerContentType
#endstruct

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