| Server IP : 209.209.40.120 / Your IP : 216.73.217.112 Web Server : Microsoft-IIS/10.0 System : Windows NT NEWWWW 10.0 build 17763 (Windows Server 2019) i586 User : NEWWWW$ ( 0) PHP Version : 8.3.30 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/shared/ |
Upload File : |
/*++
Copyright (c) 2007 Microsoft Corporation
Module Name:
winbio_types.h
Abstract:
Type definitions, constants, and structures used
by Windows Biometrics components.
Environment:
User or Kernel mode.
Revision History:
--*/
#ifndef _WINBIO_TYPES_H_712486DB_3EF5_41da_937A_55DCB7B66A53_
#define _WINBIO_TYPES_H_712486DB_3EF5_41da_937A_55DCB7B66A53_
#if (NTDDI_VERSION >= NTDDI_WIN7)
#pragma warning( push )
#pragma warning( disable : 4324 ) // structure-padding message
#ifdef __cplusplus
extern "C"{
#endif
///////////////////////////////////////////////////////////////////////////////
//
// Types used throughout WinBio
//
///////////////////////////////////////////////////////////////////////////////
typedef ULONG WINBIO_UNIT_ID, *PWINBIO_UNIT_ID;
typedef ULONG WINBIO_SESSION_HANDLE, *PWINBIO_SESSION_HANDLE;
typedef WINBIO_SESSION_HANDLE WINBIO_FRAMEWORK_HANDLE, *PWINBIO_FRAMEWORK_HANDLE;
//
// A GUID
//
typedef GUID WINBIO_UUID, *PWINBIO_UUID;
//
// Represents a NULL-terminated Unicode character
// string inside a fixed-length buffer.
//
#define WINBIO_MAX_STRING_LEN 256
typedef WCHAR WINBIO_STRING[WINBIO_MAX_STRING_LEN];
typedef WINBIO_STRING *PWINBIO_STRING;
//
// Version
//
typedef struct _WINBIO_VERSION {
DWORD MajorVersion;
DWORD MinorVersion;
} WINBIO_VERSION, *PWINBIO_VERSION;
///////////////////////////////////////////////////////////////////////////////
//
// Enumeration for template identity types...
//
typedef ULONG WINBIO_IDENTITY_TYPE, *PWINBIO_IDENTITY_TYPE;
#ifdef MIDL_PASS
const WINBIO_IDENTITY_TYPE WINBIO_ID_TYPE_NULL = (WINBIO_IDENTITY_TYPE)0; // The Identity structure is empty.
const WINBIO_IDENTITY_TYPE WINBIO_ID_TYPE_WILDCARD = (WINBIO_IDENTITY_TYPE)1; // The Identity matches "all identities".
const WINBIO_IDENTITY_TYPE WINBIO_ID_TYPE_GUID = (WINBIO_IDENTITY_TYPE)2; // A GUID identifies the template.
const WINBIO_IDENTITY_TYPE WINBIO_ID_TYPE_SID = (WINBIO_IDENTITY_TYPE)3; // An account SID identifies the template.
const WINBIO_IDENTITY_TYPE WINBIO_ID_TYPE_SECURE_ID = (WINBIO_IDENTITY_TYPE)4; // A secure ID identifies the template.
const ULONG SECURITY_MAX_SID_SIZE = (ULONG)68;
const ULONG WINBIO_IDENTITY_SECURE_ID_SIZE = (ULONG)32;
typedef union switch(WINBIO_IDENTITY_TYPE Type) _WINBIO_IDENTITY {
case WINBIO_ID_TYPE_NULL: ULONG Null;
case WINBIO_ID_TYPE_WILDCARD: ULONG Wildcard;
case WINBIO_ID_TYPE_GUID: GUID TemplateGuid;
case WINBIO_ID_TYPE_SID: struct {
ULONG Size;
UCHAR Data[SECURITY_MAX_SID_SIZE];
} AccountSid;
case WINBIO_ID_TYPE_SECURE_ID: UCHAR SecureId[WINBIO_IDENTITY_SECURE_ID_SIZE];
} WINBIO_IDENTITY;
#else // MIDL_PASS
#define WINBIO_ID_TYPE_NULL ((WINBIO_IDENTITY_TYPE)0) // The Identity structure is empty.
#define WINBIO_ID_TYPE_WILDCARD ((WINBIO_IDENTITY_TYPE)1) // The Identity matches "all identities"
#define WINBIO_ID_TYPE_GUID ((WINBIO_IDENTITY_TYPE)2) // A GUID identifies the template.
#define WINBIO_ID_TYPE_SID ((WINBIO_IDENTITY_TYPE)3) // An account SID identifies the template.
#define WINBIO_ID_TYPE_SECURE_ID ((WINBIO_IDENTITY_TYPE)4) // A secure ID identifies the template.
//
// Structure that contains the identity value associated
// with a biometric template.
//
//#ifndef SECURITY_MAX_SID_SIZE
//#define SECURITY_MAX_SID_SIZE 68
//#endif
#define WINBIO_IDENTITY_SECURE_ID_SIZE ((ULONG)32)
typedef struct _WINBIO_IDENTITY {
WINBIO_IDENTITY_TYPE Type;
union {
ULONG Null;
ULONG Wildcard;
GUID TemplateGuid;
struct {
ULONG Size;
UCHAR Data[SECURITY_MAX_SID_SIZE];
} AccountSid;
#if (NTDDI_VERSION >= NTDDI_WIN10_RS4)
UCHAR SecureId[WINBIO_IDENTITY_SECURE_ID_SIZE];
#endif
} Value;
} WINBIO_IDENTITY;
#endif // MIDL_PASS
typedef WINBIO_IDENTITY *PWINBIO_IDENTITY;
#define WINBIO_IDENTITY_WILDCARD ((ULONG)0x25066282)
///////////////////////////////////////////////////////////////////////////////
//
// Bitmask describing the supported set of biometric types (factors).
//
typedef ULONG32 WINBIO_BIOMETRIC_TYPE, *PWINBIO_BIOMETRIC_TYPE;
#ifdef MIDL_PASS
const WINBIO_BIOMETRIC_TYPE WINBIO_STANDARD_TYPE_MASK = (WINBIO_BIOMETRIC_TYPE)0x00FFFFFF;
const WINBIO_BIOMETRIC_TYPE WINBIO_NO_TYPE_AVAILABLE = (WINBIO_BIOMETRIC_TYPE)0x00000000;
//
// Standard biometric types (from NISTIR 6529-A)
//
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_MULTIPLE = (WINBIO_BIOMETRIC_TYPE)0x00000001;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_FACIAL_FEATURES = (WINBIO_BIOMETRIC_TYPE)0x00000002;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_VOICE = (WINBIO_BIOMETRIC_TYPE)0x00000004;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_FINGERPRINT = (WINBIO_BIOMETRIC_TYPE)0x00000008;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_IRIS = (WINBIO_BIOMETRIC_TYPE)0x00000010;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_RETINA = (WINBIO_BIOMETRIC_TYPE)0x00000020;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_HAND_GEOMETRY = (WINBIO_BIOMETRIC_TYPE)0x00000040;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_SIGNATURE_DYNAMICS = (WINBIO_BIOMETRIC_TYPE)0x00000080;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_KEYSTROKE_DYNAMICS = (WINBIO_BIOMETRIC_TYPE)0x00000100;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_LIP_MOVEMENT = (WINBIO_BIOMETRIC_TYPE)0x00000200;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_THERMAL_FACE_IMAGE = (WINBIO_BIOMETRIC_TYPE)0x00000400;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_THERMAL_HAND_IMAGE = (WINBIO_BIOMETRIC_TYPE)0x00000800;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_GAIT = (WINBIO_BIOMETRIC_TYPE)0x00001000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_SCENT = (WINBIO_BIOMETRIC_TYPE)0x00002000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_DNA = (WINBIO_BIOMETRIC_TYPE)0x00004000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_EAR_SHAPE = (WINBIO_BIOMETRIC_TYPE)0x00008000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_FINGER_GEOMETRY = (WINBIO_BIOMETRIC_TYPE)0x00010000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_PALM_PRINT = (WINBIO_BIOMETRIC_TYPE)0x00020000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_VEIN_PATTERN = (WINBIO_BIOMETRIC_TYPE)0x00040000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_FOOT_PRINT = (WINBIO_BIOMETRIC_TYPE)0x00080000;
//
// WinBio extended types
//
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_OTHER = (WINBIO_BIOMETRIC_TYPE)0x40000000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_PASSWORD = (WINBIO_BIOMETRIC_TYPE)0x80000000;
const WINBIO_BIOMETRIC_TYPE WINBIO_TYPE_ANY = (WINBIO_BIOMETRIC_TYPE)(WINBIO_STANDARD_TYPE_MASK | WINBIO_TYPE_OTHER | WINBIO_TYPE_PASSWORD);
#else // MIDL_PASS
#define WINBIO_STANDARD_TYPE_MASK ((WINBIO_BIOMETRIC_TYPE)0x00FFFFFF)
#define WINBIO_NO_TYPE_AVAILABLE ((WINBIO_BIOMETRIC_TYPE)0x00000000)
//
// Standard biometric types (from NISTIR 6529-A)
//
#define WINBIO_TYPE_MULTIPLE ((WINBIO_BIOMETRIC_TYPE)0x00000001)
#define WINBIO_TYPE_FACIAL_FEATURES ((WINBIO_BIOMETRIC_TYPE)0x00000002)
#define WINBIO_TYPE_VOICE ((WINBIO_BIOMETRIC_TYPE)0x00000004)
#define WINBIO_TYPE_FINGERPRINT ((WINBIO_BIOMETRIC_TYPE)0x00000008)
#define WINBIO_TYPE_IRIS ((WINBIO_BIOMETRIC_TYPE)0x00000010)
#define WINBIO_TYPE_RETINA ((WINBIO_BIOMETRIC_TYPE)0x00000020)
#define WINBIO_TYPE_HAND_GEOMETRY ((WINBIO_BIOMETRIC_TYPE)0x00000040)
#define WINBIO_TYPE_SIGNATURE_DYNAMICS ((WINBIO_BIOMETRIC_TYPE)0x00000080)
#define WINBIO_TYPE_KEYSTROKE_DYNAMICS ((WINBIO_BIOMETRIC_TYPE)0x00000100)
#define WINBIO_TYPE_LIP_MOVEMENT ((WINBIO_BIOMETRIC_TYPE)0x00000200)
#define WINBIO_TYPE_THERMAL_FACE_IMAGE ((WINBIO_BIOMETRIC_TYPE)0x00000400)
#define WINBIO_TYPE_THERMAL_HAND_IMAGE ((WINBIO_BIOMETRIC_TYPE)0x00000800)
#define WINBIO_TYPE_GAIT ((WINBIO_BIOMETRIC_TYPE)0x00001000)
#define WINBIO_TYPE_SCENT ((WINBIO_BIOMETRIC_TYPE)0x00002000)
#define WINBIO_TYPE_DNA ((WINBIO_BIOMETRIC_TYPE)0x00004000)
#define WINBIO_TYPE_EAR_SHAPE ((WINBIO_BIOMETRIC_TYPE)0x00008000)
#define WINBIO_TYPE_FINGER_GEOMETRY ((WINBIO_BIOMETRIC_TYPE)0x00010000)
#define WINBIO_TYPE_PALM_PRINT ((WINBIO_BIOMETRIC_TYPE)0x00020000)
#define WINBIO_TYPE_VEIN_PATTERN ((WINBIO_BIOMETRIC_TYPE)0x00040000)
#define WINBIO_TYPE_FOOT_PRINT ((WINBIO_BIOMETRIC_TYPE)0x00080000)
//
// WinBio extended types
//
#define WINBIO_TYPE_OTHER ((WINBIO_BIOMETRIC_TYPE)0x40000000)
#define WINBIO_TYPE_PASSWORD ((WINBIO_BIOMETRIC_TYPE)0x80000000)
#define WINBIO_TYPE_ANY ((WINBIO_BIOMETRIC_TYPE)(WINBIO_STANDARD_TYPE_MASK | \
WINBIO_TYPE_OTHER | \
WINBIO_TYPE_PASSWORD))
#endif // MIDL_PASS
//
// WinBio sensor sub-types. These are defined per Biometric type, and are
// defined only for fingerprints in this version.
//
typedef ULONG WINBIO_BIOMETRIC_SENSOR_SUBTYPE, *PWINBIO_BIOMETRIC_SENSOR_SUBTYPE;
#define WINBIO_SENSOR_SUBTYPE_UNKNOWN ((WINBIO_BIOMETRIC_SENSOR_SUBTYPE)0x00000000)
#define WINBIO_FP_SENSOR_SUBTYPE_SWIPE ((WINBIO_BIOMETRIC_SENSOR_SUBTYPE)0x00000001)
#define WINBIO_FP_SENSOR_SUBTYPE_TOUCH ((WINBIO_BIOMETRIC_SENSOR_SUBTYPE)0x00000002)
//
// Bitmask of sensor capabilities
//
typedef ULONG WINBIO_CAPABILITIES, *PWINBIO_CAPABILITIES;
#define WINBIO_CAPABILITY_SENSOR ((WINBIO_CAPABILITIES)0x00000001)
#define WINBIO_CAPABILITY_MATCHING ((WINBIO_CAPABILITIES)0x00000002)
#define WINBIO_CAPABILITY_DATABASE ((WINBIO_CAPABILITIES)0x00000004)
#define WINBIO_CAPABILITY_PROCESSING ((WINBIO_CAPABILITIES)0x00000008)
#define WINBIO_CAPABILITY_ENCRYPTION ((WINBIO_CAPABILITIES)0x00000010)
#define WINBIO_CAPABILITY_NAVIGATION ((WINBIO_CAPABILITIES)0x00000020)
#define WINBIO_CAPABILITY_INDICATOR ((WINBIO_CAPABILITIES)0x00000040)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#define WINBIO_CAPABILITY_VIRTUAL_SENSOR ((WINBIO_CAPABILITIES)0x00000080)
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#if (NTDDI_VERSION >= NTDDI_WIN10_RS1)
#define WINBIO_CAPABILITY_SECURE_SENSOR ((WINBIO_CAPABILITIES)0x00000100)
#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS1)
#if (NTDDI_VERSION >= NTDDI_WIN10_RS4)
// Secure Connection Protocol (SCP) V1
#define WINBIO_CAPABILITY_SCP_V1 ((WINBIO_CAPABILITIES)0x00000200)
// Modern standby support
#define WINBIO_CAPABILITY_WAKE ((WINBIO_CAPABILITIES)0x00000400)
//
// Constants for the SCP V1 protocol
//
typedef USHORT WINBIO_SCP_VERSION;
#define WINBIO_SCP_VERSION_1 1
// Sizes for the fixed V1 cipher suite
#define WINBIO_SCP_RANDOM_SIZE_V1 32
#define WINBIO_SCP_DIGEST_SIZE_V1 32 // SHA256
#define WINBIO_SCP_CURVE_FIELD_SIZE_V1 32 // NIST P256
#define WINBIO_SCP_PUBLIC_KEY_SIZE_V1 65 // 0x04||x||y
#define WINBIO_SCP_PRIVATE_KEY_SIZE_V1 32 // log_2(n)/8
#define WINBIO_SCP_SIGNATURE_SIZE_V1 64 // r||s
#define WINBIO_SCP_ENCRYPTION_BLOCK_SIZE_V1 16 // AES
#define WINBIO_SCP_ENCRYPTION_KEY_SIZE_V1 32 // AES256
typedef USHORT WINBIO_SCP_FLAGS;
#define WINBIO_SCP_FLAG_RECONNECT ((WINBIO_SCP_FLAGS)0x0001)
//
// Secure Connection Protocol structures
//
typedef struct _WINBIO_SECURE_CONNECTION_PARAMS {
DWORD PayloadSize;
WINBIO_SCP_VERSION Version; // WINBIO_SCP_VERSION_1
WINBIO_SCP_FLAGS Flags;
// Required fields:
// HostRandom[WINBIO_SCP_RANDOM_SIZE_V1];
// Fields omitted for reconnection:
// PublicKey[WINBIO_SCP_PUBLIC_KEY_SIZE_V1]
} WINBIO_SECURE_CONNECTION_PARAMS, *PWINBIO_SECURE_CONNECTION_PARAMS;
typedef struct _WINBIO_SECURE_CONNECTION_DATA {
DWORD Size;
WINBIO_SCP_VERSION Version; // WINBIO_SCP_VERSION_1
WINBIO_SCP_FLAGS Flags;
DWORD ModelCertificateSize;
DWORD IntermediateCA1Size;
DWORD IntermediateCA2Size;
// Required fields:
// Mac[WINBIO_SCP_DIGEST_SIZE_V1];
// Fields omitted for reconnection:
// DeviceRandom[WINBIO_SCP_RANDOM_SIZE_V1]
// ModelCertificate[ModelCertificateSize]
// DevicePublicKey[WINBIO_SCP_PUBLIC_KEY_SIZE_V1]
// FirmwarePublicKey[WINBIO_SPC_PUBLIC_KEY_SIZE_V1]
// FirmwareHash[WINBIO_SCP_DIGEST_SIZE_V1]
// ModelSignature[WINBIO_SCP_SIGNATURE_SIZE_V1]
// DeviceSignature[WINBIO_SCP_SIGNATURE_SIZE_V1]
// Field required the driver needs to append for full connection:
// IntermediateCA1[IntermediateCA1Size]
// IntermediateCA2[IntermediateCA2Size]
} WINBIO_SECURE_CONNECTION_DATA, *PWINBIO_SECURE_CONNECTION_DATA;
//
// Values representing the reason the sensor woke the host
//
typedef ULONG WINBIO_WAKE_REASON, *PWINBIO_WAKE_REASON;
#define WINBIO_WAKE_REASON_UNKNOWN ((WINBIO_WAKE_REASON)0)
#define WINBIO_WAKE_REASON_TOUCH ((WINBIO_WAKE_REASON)1)
#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS4)
//
// Values representing the operating status of a sensor
//
typedef ULONG WINBIO_SENSOR_STATUS, *PWINBIO_SENSOR_STATUS;
#define WINBIO_SENSOR_STATUS_UNKNOWN ((WINBIO_SENSOR_STATUS)0)
#define WINBIO_SENSOR_ACCEPT ((WINBIO_SENSOR_STATUS)1)
#define WINBIO_SENSOR_REJECT ((WINBIO_SENSOR_STATUS)2)
#define WINBIO_SENSOR_READY ((WINBIO_SENSOR_STATUS)3)
#define WINBIO_SENSOR_BUSY ((WINBIO_SENSOR_STATUS)4)
#define WINBIO_SENSOR_NOT_CALIBRATED ((WINBIO_SENSOR_STATUS)5)
#define WINBIO_SENSOR_FAILURE ((WINBIO_SENSOR_STATUS)6)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
//
// The following only apply to VIRTUAL_SENSOR units
//
#define WINBIO_SENSOR_AVAILABLE ((WINBIO_SENSOR_STATUS)7)
#define WINBIO_SENSOR_UNAVAILABLE ((WINBIO_SENSOR_STATUS)8)
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
//
// Values used to set the indicator on or off
//
// By default, sensors will not have a light on.
// Applications can use these values to enable
// or disable indicator lights on the sensor.
// WINBIO_SENSOR_STATUS will provide more detail
// about the status of the light when it is "on."
//
typedef DWORD WINBIO_INDICATOR_STATUS, *PWINBIO_INDICATOR_STATUS;
#define WINBIO_INDICATOR_ON ((WINBIO_INDICATOR_STATUS)1)
#define WINBIO_INDICATOR_OFF ((WINBIO_INDICATOR_STATUS)2)
///////////////////////////////////////////////////////////////////////////////
//
// Sensor operating modes
//
typedef ULONG WINBIO_SENSOR_MODE, *PWINBIO_SENSOR_MODE;
#define WINBIO_SENSOR_UNKNOWN_MODE ((WINBIO_SENSOR_MODE)0)
#define WINBIO_SENSOR_BASIC_MODE ((WINBIO_SENSOR_MODE)1)
#define WINBIO_SENSOR_ADVANCED_MODE ((WINBIO_SENSOR_MODE)2)
#define WINBIO_SENSOR_NAVIGATION_MODE ((WINBIO_SENSOR_MODE)3)
#define WINBIO_SENSOR_SLEEP_MODE ((WINBIO_SENSOR_MODE)4)
///////////////////////////////////////////////////////////////////////////////
//
// Factor-specific value giving additional information about
// a biometric measurement (e.g., *which* finger a fingerprint
// sample was taken from).
//
typedef UCHAR WINBIO_BIOMETRIC_SUBTYPE, *PWINBIO_BIOMETRIC_SUBTYPE;
#define WINBIO_SUBTYPE_NO_INFORMATION ((WINBIO_BIOMETRIC_SUBTYPE)0x00)
#define WINBIO_SUBTYPE_ANY ((WINBIO_BIOMETRIC_SUBTYPE)0xFF)
//
// If the biometric type is WINBIO_TYPE_FINGERPRINT, WinBio uses
// 'WINBIO_ANSI_381_POS_xyz' constants to represent fingerprint sub-type
// information. (These are defined below in the WINBIO_BDB_ANSI_381_RECORD.)
//
// If the biometric type is WINBIO_TYPE_FACIAL_FEATURES, WinBio uses
// 'WINBIO_ANSI_385_xyz' constants to represent facial image sub-type
// information.
//
#if (NTDDI_VERSION >= NTDDI_WIN10_RS5)
///////////////////////////////////////////////////////////////////////////////
//
// Biometric unit security level
//
typedef ULONG WINBIO_UNIT_SECURITY_LEVEL, *PWINBIO_UNIT_SECURITY_LEVEL;
#define WINBIO_UNIT_SECURITY_LEVEL_NORMAL ((WINBIO_UNIT_SECURITY_LEVEL)0)
#define WINBIO_UNIT_SECURITY_LEVEL_VBS ((WINBIO_UNIT_SECURITY_LEVEL)1)
#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS5)
///////////////////////////////////////////////////////////////////////////////
//
// Factor-specific value that describes the reason a
// biometric sampling operation failed.
//
typedef ULONG WINBIO_REJECT_DETAIL, *PWINBIO_REJECT_DETAIL;
#ifndef WINBIO_REJECT_DETAILS_DEFINED
#define WINBIO_REJECT_DETAILS_DEFINED
//
// Reject detail values for WINBIO_TYPE_FINGERPRINT
//
#define WINBIO_FP_TOO_HIGH ((WINBIO_REJECT_DETAIL)1)
#define WINBIO_FP_TOO_LOW ((WINBIO_REJECT_DETAIL)2)
#define WINBIO_FP_TOO_LEFT ((WINBIO_REJECT_DETAIL)3)
#define WINBIO_FP_TOO_RIGHT ((WINBIO_REJECT_DETAIL)4)
#define WINBIO_FP_TOO_FAST ((WINBIO_REJECT_DETAIL)5)
#define WINBIO_FP_TOO_SLOW ((WINBIO_REJECT_DETAIL)6)
#define WINBIO_FP_POOR_QUALITY ((WINBIO_REJECT_DETAIL)7)
#define WINBIO_FP_TOO_SKEWED ((WINBIO_REJECT_DETAIL)8)
#define WINBIO_FP_TOO_SHORT ((WINBIO_REJECT_DETAIL)9)
#define WINBIO_FP_MERGE_FAILURE ((WINBIO_REJECT_DETAIL)10)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
//
// REJECT_DETAIL values for IRIS and FACIAL_FEATURES contain multiple fields:
//
// - Flags requesting proof-of-liveness behaviors from the user [0xFF000000]
// - Flags indicating of position errors [0x00FF0000]
// - A (single) enumerated value explaining the reason for the rejection. [0x0000FFFF]
//
// This mask covers the upper 8 bits of the reject detail value, where
// the proof-of-liveness behaviors are located.
//
#define WINBIO_REJECT_DETAIL_ANTI_SPOOF_MASK ((WINBIO_REJECT_DETAIL)0xFF000000)
//
// Anti-spoofing behaviors...
//
#define WINBIO_ANTI_SPOOF_TURN_SIDE_TO_SIDE ((WINBIO_REJECT_DETAIL)0x01000000)
//
// This mask covers the range of bits devoted to position errors...
//
#define WINBIO_REJECT_DETAIL_POSITION_MASK ((WINBIO_REJECT_DETAIL)0x00FF0000)
//
// This mask covers the lower 16 bits, where the enumerated reason for the
// rejection is located.
//
#define WINBIO_REJECT_DETAIL_REASON_MASK ((WINBIO_REJECT_DETAIL)0x0000FFFF)
//
// Reject detail values for WINBIO_TYPE_IRIS
//
#define WINBIO_IRIS_POOR_QUALITY ((WINBIO_REJECT_DETAIL)1)
#define WINBIO_IRIS_TOO_BRIGHT ((WINBIO_REJECT_DETAIL)2)
#define WINBIO_IRIS_TOO_DARK ((WINBIO_REJECT_DETAIL)3)
#define WINBIO_IRIS_SPOOF_DETECTED ((WINBIO_REJECT_DETAIL)4)
#define WINBIO_IRIS_TOO_SKEWED ((WINBIO_REJECT_DETAIL)5)
#define WINBIO_IRIS_TOO_CLOSED ((WINBIO_REJECT_DETAIL)6)
#define WINBIO_IRIS_GLARE ((WINBIO_REJECT_DETAIL)7)
#define WINBIO_IRIS_DIRTY_LENS ((WINBIO_REJECT_DETAIL)8)
#define WINBIO_IRIS_POOR_FOCUS ((WINBIO_REJECT_DETAIL)9)
// Camera orientation doesn't match mandatory value in EXTENDED_SENSOR_INFO
#define WINBIO_IRIS_WRONG_ORIENTATION ((WINBIO_REJECT_DETAIL)10)
//
// Positioning errors...
//
#define WINBIO_IRIS_TOO_HIGH ((WINBIO_REJECT_DETAIL)0x00010000)
#define WINBIO_IRIS_TOO_LOW ((WINBIO_REJECT_DETAIL)0x00020000)
#define WINBIO_IRIS_TOO_LEFT ((WINBIO_REJECT_DETAIL)0x00040000)
#define WINBIO_IRIS_TOO_RIGHT ((WINBIO_REJECT_DETAIL)0x00080000)
#define WINBIO_IRIS_TOO_NEAR ((WINBIO_REJECT_DETAIL)0x00100000)
#define WINBIO_IRIS_TOO_FAR ((WINBIO_REJECT_DETAIL)0x00200000)
//
// Reject detail values for WINBIO_TYPE_FACIAL_FEATURES
//
#define WINBIO_FACE_POOR_QUALITY ((WINBIO_REJECT_DETAIL)1)
#define WINBIO_FACE_TOO_BRIGHT ((WINBIO_REJECT_DETAIL)2)
#define WINBIO_FACE_TOO_DARK ((WINBIO_REJECT_DETAIL)3)
//
// SPOOF_DETECTED indicates that the recognition component believes the
// face is not live, but is coming from a replayed video feed, a photo,
// or a 3-D sculpture.
//
#define WINBIO_FACE_SPOOF_DETECTED ((WINBIO_REJECT_DETAIL)4)
#define WINBIO_FACE_AMBIGUOUS_TARGET ((WINBIO_REJECT_DETAIL)5)
#define WINBIO_FACE_EYES_OCCLUDED ((WINBIO_REJECT_DETAIL)6)
// Camera orientation doesn't match mandatory value in EXTENDED_SENSOR_INFO
#define WINBIO_FACE_WRONG_ORIENTATION ((WINBIO_REJECT_DETAIL)7)
//
// Positioning errors...
//
#define WINBIO_FACE_TOO_HIGH ((WINBIO_REJECT_DETAIL)0x00010000)
#define WINBIO_FACE_TOO_LOW ((WINBIO_REJECT_DETAIL)0x00020000)
#define WINBIO_FACE_TOO_LEFT ((WINBIO_REJECT_DETAIL)0x00040000)
#define WINBIO_FACE_TOO_RIGHT ((WINBIO_REJECT_DETAIL)0x00080000)
#define WINBIO_FACE_TOO_NEAR ((WINBIO_REJECT_DETAIL)0x00100000)
#define WINBIO_FACE_TOO_FAR ((WINBIO_REJECT_DETAIL)0x00200000)
//
// Reject detail values for WINBIO_TYPE_VOICE
//
#define WINBIO_VOICE_POOR_QUALITY ((WINBIO_REJECT_DETAIL)1)
#define WINBIO_VOICE_TOO_SLOW ((WINBIO_REJECT_DETAIL)2)
#define WINBIO_VOICE_TOO_FAST ((WINBIO_REJECT_DETAIL)3)
#define WINBIO_VOICE_NO_KEYWORD ((WINBIO_REJECT_DETAIL)4)
#define WINBIO_VOICE_PROCESSING_ERROR ((WINBIO_REJECT_DETAIL)5)
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#endif // WINBIO_REJECT_DETAILS_DEFINED
///////////////////////////////////////////////////////////////////////////////
//
// Biometric Information Record (BIR)
//
///////////////////////////////////////////////////////////////////////////////
//
// +---------------------------------------+
// 1. | WINBIO_BIR |
// +---------------------------------------+
// 2. | WINBIO_BIR_HEADER |
// +---------------------------------------+
// 3. | Standard Data Block (optional) |
// | |
// | WINBIO_BDB_ANSI_381_HEADER |
// | [0] WINBIO_BDB_ANSI_381_RECORD |
// | : |
// | [N] WINBIO_BDB_ANSI_381_RECORD |
// +---------------------------------------+
// 4. | Vendor Data Block (optional) |
// +---------------------------------------+
// 5. | Signature Block (optional) |
// +---------------------------------------+
//
// NOTES:
// - The format of the Standard Data Block is determined
// by the 'BiometricDataFormat' field of WINBIO_BIR_HEADER.
//
// - Currently, the only supported format for the Standard
// Data Block is ANSI 381 fingerprint image data. Data in
// any other form must go into the Vendor Data Block instead.
//
// - It's vital that BIR structures and sub-structures be aligned
// on 8-byte boundaries. This means both C++ and MIDL compilation
// with at least /Zp8 alignment. This also applies to BIRs that
// are allocated dynamically from the heap.
//
#define WINBIO_BIR_ALIGN_SIZE (8)
//
// Also define legacy typo to be synonymous
//
#define WINBIO_BIR_ALGIN_SIZE WINBIO_BIR_ALIGN_SIZE
//
// The following gives the location and size of a block
// in a BIR. The offset is measured from the beginning of
// the WINBIO_BIR structure.
//
typedef struct _WINBIO_BIR_DATA {
ULONG Size;
ULONG Offset;
} WINBIO_BIR_DATA;
typedef WINBIO_BIR_DATA *PWINBIO_BIR_DATA;
//
// Top-level structure contains offset/size
// information needed to find other items.
//
typedef struct _WINBIO_BIR {
WINBIO_BIR_DATA HeaderBlock;
WINBIO_BIR_DATA StandardDataBlock;
WINBIO_BIR_DATA VendorDataBlock;
WINBIO_BIR_DATA SignatureBlock;
} WINBIO_BIR;
typedef WINBIO_BIR *PWINBIO_BIR;
///////////////////////////////////////////////////////////////////////////////
//
// Elements used in a BIR header
//
///////////////////////////////////////////////////////////////////////////////
//
// BIR 'ValidFields' flags...
//
#define WINBIO_BIR_FIELD_SUBHEAD_COUNT ((USHORT)0x0001)
#define WINBIO_BIR_FIELD_PRODUCT_ID ((USHORT)0x0002)
#define WINBIO_BIR_FIELD_PATRON_ID ((USHORT)0x0004)
#define WINBIO_BIR_FIELD_INDEX ((USHORT)0x0008)
#define WINBIO_BIR_FIELD_CREATION_DATE ((USHORT)0x0010)
#define WINBIO_BIR_FIELD_VALIDITY_PERIOD ((USHORT)0x0020)
#define WINBIO_BIR_FIELD_BIOMETRIC_TYPE ((USHORT)0x0040)
#define WINBIO_BIR_FIELD_BIOMETRIC_SUBTYPE ((USHORT)0x0080)
#define WINBIO_BIR_FIELD_CBEFF_HEADER_VERSION ((USHORT)0x0100)
#define WINBIO_BIR_FIELD_PATRON_HEADER_VERSION ((USHORT)0x0200)
#define WINBIO_BIR_FIELD_BIOMETRIC_PURPOSE ((USHORT)0x0400)
#define WINBIO_BIR_FIELD_BIOMETRIC_CONDITION ((USHORT)0x0800)
#define WINBIO_BIR_FIELD_QUALITY ((USHORT)0x1000)
#define WINBIO_BIR_FIELD_CREATOR ((USHORT)0x2000)
#define WINBIO_BIR_FIELD_CHALLENGE ((USHORT)0x4000)
#define WINBIO_BIR_FIELD_PAYLOAD ((USHORT)0x8000)
//
// The following collection of optional fields will NEVER be
// part of a WinBio BIR. If any of these bits are asserted,
// the BIR is malformed.
//
#define WINBIO_BIR_FIELD_NEVER_VALID (WINBIO_BIR_FIELD_SUBHEAD_COUNT | \
WINBIO_BIR_FIELD_PATRON_ID | \
WINBIO_BIR_FIELD_INDEX | \
WINBIO_BIR_FIELD_CHALLENGE | \
WINBIO_BIR_FIELD_PAYLOAD )
///////////////////////////////////////////////////////////////////////////////
//
// BIR 'HeaderVersion' and 'PatronHeaderVersion' fields:
//
// Versions are represented as 8-bit values of the
// form: 0xNM, where 'N' is the major version and 'M'
// is the minor version.
//
typedef UCHAR WINBIO_BIR_VERSION, *PWINBIO_BIR_VERSION;
#define WINBIO_CBEFF_HEADER_VERSION ((WINBIO_BIR_VERSION)0x11)
#define WINBIO_PATRON_HEADER_VERSION ((WINBIO_BIR_VERSION)0x11)
///////////////////////////////////////////////////////////////////////////////
//
// BIR 'DataFlags' field:
// * Security and integrity-checking options
// PRIVACY - BDB is encrypted
// INTEGRITY - BDB is signed or MAC'ed
// SIGNED - 1 -> BDB is signed; 0 -> BDB is MAC'ed
// * Processing level of the data
//
typedef UCHAR WINBIO_BIR_DATA_FLAGS, *PWINBIO_BIR_DATA_FLAGS;
#define WINBIO_DATA_FLAG_PRIVACY ((UCHAR)0x02)
#define WINBIO_DATA_FLAG_INTEGRITY ((UCHAR)0x01)
#define WINBIO_DATA_FLAG_SIGNED ((UCHAR)0x04)
#define WINBIO_DATA_FLAG_RAW ((UCHAR)0x20)
#define WINBIO_DATA_FLAG_INTERMEDIATE ((UCHAR)0x40)
#define WINBIO_DATA_FLAG_PROCESSED ((UCHAR)0x80)
#define WINBIO_DATA_FLAG_OPTION_MASK_PRESENT ((UCHAR)0x08) // Always '1'.
///////////////////////////////////////////////////////////////////////////////
//
// BIR 'Purpose' field:
//
// A value defining the purpose for which the BIR
//
// - is intended, when used as input to a WinBio function
//
// - is suitable, when used as output from a WinBio function
// or within a BIR header.
//
// NOTE:
// In a WINBIO BIR, the 'Purpose' field is defined as a set of flag bits
// rather than an enumerated type (as specified in NISTIR 6529-A). Transferring
// a WINBIO BIR to another environment (e.g., BioAPI) will require conversion.
//
// The suggested way to handle this conversion is to generate a set of nested
// BIRs for any WINBIO BIRs that have multiple 'Purpose' bits set.
//
typedef UCHAR WINBIO_BIR_PURPOSE, *PWINBIO_BIR_PURPOSE;
#define WINBIO_NO_PURPOSE_AVAILABLE ((WINBIO_BIR_PURPOSE)0x00)
#define WINBIO_PURPOSE_VERIFY ((WINBIO_BIR_PURPOSE)0x01)
#define WINBIO_PURPOSE_IDENTIFY ((WINBIO_BIR_PURPOSE)0x02)
#define WINBIO_PURPOSE_ENROLL ((WINBIO_BIR_PURPOSE)0x04)
#define WINBIO_PURPOSE_ENROLL_FOR_VERIFICATION ((WINBIO_BIR_PURPOSE)0x08)
#define WINBIO_PURPOSE_ENROLL_FOR_IDENTIFICATION ((WINBIO_BIR_PURPOSE)0x10)
#define WINBIO_PURPOSE_AUDIT ((WINBIO_BIR_PURPOSE)0x80)
///////////////////////////////////////////////////////////////////////////////
//
// BIR 'DataQuality' field:
//
// FIndicates the relative quality of the biometric
// data in the BIR.
//
// Quality measurements are represented as signed
// integers in the range 0-100, except:
//
// -1 Quality measurements are supported by the
// BIR creator, but no value is set in the BIR.
//
// -2 Quality measurements are not supported
// by the BIR creator.
//
typedef CHAR WINBIO_BIR_QUALITY, *PWINBIO_BIR_QUALITY;
#define WINBIO_DATA_QUALITY_NOT_SET ((WINBIO_BIR_QUALITY)-1)
#define WINBIO_DATA_QUALITY_NOT_SUPPORTED ((WINBIO_BIR_QUALITY)-2)
///////////////////////////////////////////////////////////////////////////////
//
// BIR 'BiometricDataFormat' and 'ProductId' fields:
//
// Identifies a registered data format as a pair consisting of
// an IBIA-assigned owner value plus an owner-assigned format-type
// value.
//
typedef struct _WINBIO_REGISTERED_FORMAT {
USHORT Owner;
USHORT Type;
} WINBIO_REGISTERED_FORMAT, *PWINBIO_REGISTERED_FORMAT;
#define WINBIO_NO_FORMAT_OWNER_AVAILABLE ((USHORT)0)
#define WINBIO_NO_FORMAT_TYPE_AVAILABLE ((USHORT)0)
///////////////////////////////////////////////////////////////////////////////
//
// NISTIR 6529-A -- Common Biometric Exchange Formats Framework (CBEFF)
// April 5, 2004
//
// CBEFF Patron Format A: Standard Biometric Header Block
//
// NOTE:
// This structure is COMPATIBLE with CBEFF Patron Format A in that
// it can be transformed to/from a fully-conformant Format A record.
// The following fields are NOT part of this structure:
// - Subheader -- WinBio doesn't support nested CBEFF structures
// - Patron format owner/type -- used only for nested CBEFF structures
// - Index
// - Creator
// - Challenge/response
// - Payload
//
///////////////////////////////////////////////////////////////////////////////
typedef struct _WINBIO_BIR_HEADER {
//
// Mask indicating which fields are valid
//
// Annex A -- Note (1) to Table A.1
//
USHORT ValidFields;
//
// CBEFF Header version
//
// SECTION 5.2.1.3
//
WINBIO_BIR_VERSION HeaderVersion; // = WINBIO_CBEFF_HEADER_VERSION
//
// Patron header version
//
// SECTION 5.2.1.4
//
WINBIO_BIR_VERSION PatronHeaderVersion; // = WINBIO_PATRON_HEADER_VERSION
//
// 'DataFlags' is a combination of the 'Security
// Options' field and the 'Biometric Data Type'
// (RAW, INTERMEDIATE,PROCESSED) field.
//
// SECTION 5.2.1.1, 5.2.1.2, and 5.2.1.7
//
WINBIO_BIR_DATA_FLAGS DataFlags;
//
// Biometric type
//
// SECTION 5.2.1.5
//
WINBIO_BIOMETRIC_TYPE Type;
//
// Biometric subtype
//
// SECTION 5.2.1.6
//
WINBIO_BIOMETRIC_SUBTYPE Subtype;
//
// Intended use of the data
//
// SECTION 5.2.1.8
//
WINBIO_BIR_PURPOSE Purpose;
//
// Biometric data quality
//
// SECTION 5.2.1.9
//
WINBIO_BIR_QUALITY DataQuality;
//
// Creation date and time of this BIR (in UTC)
//
// SECTION 5.2.1.10
//
LARGE_INTEGER CreationDate;
//
// Validity period of this BIR (in UTC)
//
// SECTION 5.2.1.11
//
struct {
LARGE_INTEGER BeginDate;
LARGE_INTEGER EndDate;
} ValidityPeriod;
///////////////////////////////////////////////////////////////////////////
//
// Data format of Standard Data Block.
//
// NOTE: If BIR doesn't contain 'StandardDataBlock'
// element, this is set to "no owner/type available".
//
WINBIO_REGISTERED_FORMAT BiometricDataFormat;
//
// Product identifier for the component that
// generated the 'StandardDataBlock' element.
//
// NOTE: If BIR doesn't contain 'StandardDataBlock'
// element, this is set to "no owner/type available".
//
WINBIO_REGISTERED_FORMAT ProductId;
} WINBIO_BIR_HEADER;
typedef WINBIO_BIR_HEADER *PWINBIO_BIR_HEADER;
///////////////////////////////////////////////////////////////////////////////
//
// ANSI INCITS 381-2004 -- Finger Image-Based Data Interchange Format
//
///////////////////////////////////////////////////////////////////////////////
//
// SECTION 7 -- Registered Format
//
// WINBIO_BIR_HEADER.BiometricDataFormat.Owner = WINBIO_ANSI_381_FORMAT_OWNER
// WINBIO_BIR_HEADER.BiometricDataFormat.Type = WINBIO_ANSI_381_FORMAT_TYPE
//
#define WINBIO_ANSI_381_FORMAT_OWNER ((USHORT)0x001B) // INCITS Technical Committee M1
#define WINBIO_ANSI_381_FORMAT_TYPE ((USHORT)0x0401) // ANSI-381
//
// SECTION 7.1 -- General Record Header
//
typedef struct _WINBIO_BDB_ANSI_381_HEADER {
ULONG64 RecordLength; // Only the low 6 bytes of this number are valid.
// sizeof(WINBIO_BDB_ANSI_381_HEADER)
// + sizeof( all WINBIO_BDB_ANSI_381_RECORD records)
ULONG FormatIdentifier; // Must be 0x46495200 (ASCII: 'F' 'I' 'R' 0x0)
ULONG VersionNumber; // Must be 0x30313000 (ASCII: '0' '1' '0' 0x0)
WINBIO_REGISTERED_FORMAT ProductId;
USHORT CaptureDeviceId;
USHORT ImageAcquisitionLevel;
USHORT HorizontalScanResolution;
USHORT VerticalScanResolution;
USHORT HorizontalImageResolution;
USHORT VerticalImageResolution;
UCHAR ElementCount; // Number of finger/palm records in the block
UCHAR ScaleUnits; // cm or inch
UCHAR PixelDepth; // 1-16 bits per pixel (2-64K gray levels)
UCHAR ImageCompressionAlg;
USHORT Reserved;
// 38 bytes (because of unused 2 bytes in ULONG64) vs. 36 bytes defined in ANSI INCITS spec
} WINBIO_BDB_ANSI_381_HEADER;
typedef WINBIO_BDB_ANSI_381_HEADER *PWINBIO_BDB_ANSI_381_HEADER;
//
// SECTION 7.1.6 Image acquistion level
//
// Table 1 -- Image acquistion setting levels
//
#define WINBIO_ANSI_381_IMG_ACQ_LEVEL_10 ((USHORT)10)
#define WINBIO_ANSI_381_IMG_ACQ_LEVEL_20 ((USHORT)20)
#define WINBIO_ANSI_381_IMG_ACQ_LEVEL_30 ((USHORT)30)
#define WINBIO_ANSI_381_IMG_ACQ_LEVEL_31 ((USHORT)31)
#define WINBIO_ANSI_381_IMG_ACQ_LEVEL_40 ((USHORT)40)
#define WINBIO_ANSI_381_IMG_ACQ_LEVEL_41 ((USHORT)41)
//
// SECTION 7.1.8 -- Scale units
//
#define WINBIO_ANSI_381_PIXELS_PER_INCH ((UCHAR)0x01)
#define WINBIO_ANSI_381_PIXELS_PER_CM ((UCHAR)0x02)
//
// SECTION 7.1.14 -- Image compression algorithm
//
// Table 3 -- Compression algorithm codes
//
#define WINBIO_ANSI_381_IMG_UNCOMPRESSED ((UCHAR)0)
#define WINBIO_ANSI_381_IMG_BIT_PACKED ((UCHAR)1)
#define WINBIO_ANSI_381_IMG_COMPRESSED_WSQ ((UCHAR)2)
#define WINBIO_ANSI_381_IMG_COMPRESSED_JPEG ((UCHAR)3)
#define WINBIO_ANSI_381_IMG_COMPRESSED_JPEG2000 ((UCHAR)4)
#define WINBIO_ANSI_381_IMG_COMPRESSED_PNG ((UCHAR)5)
//
// SECTION 7.2 -- Finger Record Header
//
typedef struct _WINBIO_BDB_ANSI_381_RECORD {
ULONG BlockLength; // sizeof(WINBIO_BDB_ANSI_381_RECORD)
// + sizeof(image data)
USHORT HorizontalLineLength; // Number of pixels in a horizontal line
USHORT VerticalLineLength; // Number of horizontal lines in the image
WINBIO_BIOMETRIC_SUBTYPE Position;
UCHAR CountOfViews; // Must be set to one (1)
UCHAR ViewNumber; // Must be set to one (1)
UCHAR ImageQuality; // Reserved -- must be set to 254 (0xFE)
UCHAR ImpressionType;
UCHAR Reserved; // Must be set to zero
// 14 bytes of header data
} WINBIO_BDB_ANSI_381_RECORD;
//
// Followed immediately by compressed/uncompressed image data.
// (Image data must be < 43 * 10^8 bytes in length.)
//
typedef WINBIO_BDB_ANSI_381_RECORD *PWINBIO_BDB_ANSI_381_RECORD;
//
// SECTION 7.2.2 -- Finger position codes
//
// Table 5 -- Finger position codes, areas, and maximum dimensions
//
#define WINBIO_ANSI_381_POS_UNKNOWN ((WINBIO_BIOMETRIC_SUBTYPE)0)
#define WINBIO_ANSI_381_POS_RH_THUMB ((WINBIO_BIOMETRIC_SUBTYPE)1)
#define WINBIO_ANSI_381_POS_RH_INDEX_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)2)
#define WINBIO_ANSI_381_POS_RH_MIDDLE_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)3)
#define WINBIO_ANSI_381_POS_RH_RING_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)4)
#define WINBIO_ANSI_381_POS_RH_LITTLE_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)5)
#define WINBIO_ANSI_381_POS_LH_THUMB ((WINBIO_BIOMETRIC_SUBTYPE)6)
#define WINBIO_ANSI_381_POS_LH_INDEX_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)7)
#define WINBIO_ANSI_381_POS_LH_MIDDLE_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)8)
#define WINBIO_ANSI_381_POS_LH_RING_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)9)
#define WINBIO_ANSI_381_POS_LH_LITTLE_FINGER ((WINBIO_BIOMETRIC_SUBTYPE)10)
#define WINBIO_ANSI_381_POS_RH_FOUR_FINGERS ((WINBIO_BIOMETRIC_SUBTYPE)13)
#define WINBIO_ANSI_381_POS_LH_FOUR_FINGERS ((WINBIO_BIOMETRIC_SUBTYPE)14)
#define WINBIO_ANSI_381_POS_TWO_THUMBS ((WINBIO_BIOMETRIC_SUBTYPE)15)
//
// Table 6 -- Palm codes, areas, and maximum dimensions
//
#define WINBIO_ANSI_381_POS_UNKNOWN_PALM ((WINBIO_BIOMETRIC_SUBTYPE)20)
#define WINBIO_ANSI_381_POS_RH_FULL_PALM ((WINBIO_BIOMETRIC_SUBTYPE)21)
#define WINBIO_ANSI_381_POS_RH_WRITERS_PALM ((WINBIO_BIOMETRIC_SUBTYPE)22)
#define WINBIO_ANSI_381_POS_LH_FULL_PALM ((WINBIO_BIOMETRIC_SUBTYPE)23)
#define WINBIO_ANSI_381_POS_LH_WRITERS_PALM ((WINBIO_BIOMETRIC_SUBTYPE)24)
#define WINBIO_ANSI_381_POS_RH_LOWER_PALM ((WINBIO_BIOMETRIC_SUBTYPE)25)
#define WINBIO_ANSI_381_POS_RH_UPPER_PALM ((WINBIO_BIOMETRIC_SUBTYPE)26)
#define WINBIO_ANSI_381_POS_LH_LOWER_PALM ((WINBIO_BIOMETRIC_SUBTYPE)27)
#define WINBIO_ANSI_381_POS_LH_UPPER_PALM ((WINBIO_BIOMETRIC_SUBTYPE)28)
#define WINBIO_ANSI_381_POS_RH_OTHER ((WINBIO_BIOMETRIC_SUBTYPE)29)
#define WINBIO_ANSI_381_POS_LH_OTHER ((WINBIO_BIOMETRIC_SUBTYPE)30)
#define WINBIO_ANSI_381_POS_RH_INTERDIGITAL ((WINBIO_BIOMETRIC_SUBTYPE)31)
#define WINBIO_ANSI_381_POS_RH_THENAR ((WINBIO_BIOMETRIC_SUBTYPE)32)
#define WINBIO_ANSI_381_POS_RH_HYPOTHENAR ((WINBIO_BIOMETRIC_SUBTYPE)33)
#define WINBIO_ANSI_381_POS_LH_INTERDIGITAL ((WINBIO_BIOMETRIC_SUBTYPE)34)
#define WINBIO_ANSI_381_POS_LH_THENAR ((WINBIO_BIOMETRIC_SUBTYPE)35)
#define WINBIO_ANSI_381_POS_LH_HYPOTHENAR ((WINBIO_BIOMETRIC_SUBTYPE)36)
//
// SECTION 7.2.6 -- Impression-Type Codes
//
// Table 7 -- Finger and palm impression types
//
#define WINBIO_ANSI_381_IMP_TYPE_LIVE_SCAN_PLAIN ((UCHAR)0)
#define WINBIO_ANSI_381_IMP_TYPE_LIVE_SCAN_ROLLED ((UCHAR)1)
#define WINBIO_ANSI_381_IMP_TYPE_NONLIVE_SCAN_PLAIN ((UCHAR)2)
#define WINBIO_ANSI_381_IMP_TYPE_NONLIVE_SCAN_ROLLED ((UCHAR)3)
#define WINBIO_ANSI_381_IMP_TYPE_LATENT ((UCHAR)7)
#define WINBIO_ANSI_381_IMP_TYPE_SWIPE ((UCHAR)8)
#define WINBIO_ANSI_381_IMP_TYPE_LIVE_SCAN_CONTACTLESS ((UCHAR)9)
#if (NTDDI_VERSION >= NTDDI_WIN9)
//
// Sub-factor values for untagged fingerprints.
// Microsoft-specific extension -- not part of ANSI/ISO standard
//
#define WINBIO_FINGER_UNSPECIFIED_POS_01 ((WINBIO_BIOMETRIC_SUBTYPE)0xF5)
#define WINBIO_FINGER_UNSPECIFIED_POS_02 ((WINBIO_BIOMETRIC_SUBTYPE)0xF6)
#define WINBIO_FINGER_UNSPECIFIED_POS_03 ((WINBIO_BIOMETRIC_SUBTYPE)0xF7)
#define WINBIO_FINGER_UNSPECIFIED_POS_04 ((WINBIO_BIOMETRIC_SUBTYPE)0xF8)
#define WINBIO_FINGER_UNSPECIFIED_POS_05 ((WINBIO_BIOMETRIC_SUBTYPE)0xF9)
#define WINBIO_FINGER_UNSPECIFIED_POS_06 ((WINBIO_BIOMETRIC_SUBTYPE)0xFA)
#define WINBIO_FINGER_UNSPECIFIED_POS_07 ((WINBIO_BIOMETRIC_SUBTYPE)0xFB)
#define WINBIO_FINGER_UNSPECIFIED_POS_08 ((WINBIO_BIOMETRIC_SUBTYPE)0xFC)
#define WINBIO_FINGER_UNSPECIFIED_POS_09 ((WINBIO_BIOMETRIC_SUBTYPE)0xFD)
#define WINBIO_FINGER_UNSPECIFIED_POS_10 ((WINBIO_BIOMETRIC_SUBTYPE)0xFE)
#endif // (NTDDI_VERSION >= NTDDI_WIN9)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
//
// Sub-factor values for face recognition, taken from:
//
// ANSI/INCITS 385-2004: "Face Recognition Format for Data Interchange"
//
// 385-2004 defines two types of frontal face images: full resolution and low
// resolution. In practice, WinBio will use only full resolution images for
// face recognition.
//
#define WINBIO_ANSI_385_FACE_TYPE_UNKNOWN ((WINBIO_BIOMETRIC_SUBTYPE)0)
#define WINBIO_ANSI_385_FACE_FRONTAL_FULL ((WINBIO_BIOMETRIC_SUBTYPE)1)
#define WINBIO_ANSI_385_FACE_FRONTAL_TOKEN ((WINBIO_BIOMETRIC_SUBTYPE)2)
//
// Sub-factor values for iris recognition.
//
// Microsoft-specific extension -- not part of ANSI/ISO standards
// (ANSI/INCITS 379-2004 doesn't define any left/right eye values)
//
#define WINBIO_IRIS_TYPE_UNKNOWN ((WINBIO_BIOMETRIC_SUBTYPE)0)
#define WINBIO_IRIS_LEFT_EYE ((WINBIO_BIOMETRIC_SUBTYPE)0xF5)
#define WINBIO_IRIS_RIGHT_EYE ((WINBIO_BIOMETRIC_SUBTYPE)0xF6)
#define WINBIO_IRIS_UNSPECIFIED_POS_01 ((WINBIO_BIOMETRIC_SUBTYPE)0xF7)
#define WINBIO_IRIS_UNSPECIFIED_POS_02 ((WINBIO_BIOMETRIC_SUBTYPE)0xF8)
#define WINBIO_IRIS_BOTH_EYES ((WINBIO_BIOMETRIC_SUBTYPE)0xF9)
#define WINBIO_IRIS_EITHER_EYE ((WINBIO_BIOMETRIC_SUBTYPE)0xFA)
//
// Sub-factor values for voice recognition.
//
// Microsoft-specific extension. Each "sub-factor" is a separate utterance.
//
// An enrollment appication can create multiple templates for a single SID,
// each template corresponding to a unique "utterance". The enrollment's
// SubFactor value is used to identify a specific utterance. The SubFactor
// can be any value between WINBIO_VOICE_MIN_UTTERANCE and WINBIO_VOICE_MAX_UTTERANCE.
// After enrollment, WinBioIdentify will return the utterance ID through the
// SubFactor return value.
//
#define WINBIO_VOICE_TYPE_UNKNOWN ((WINBIO_BIOMETRIC_SUBTYPE)0)
#define WINBIO_VOICE_MIN_UTTERANCE ((WINBIO_BIOMETRIC_SUBTYPE)1)
#define WINBIO_VOICE_MAX_UTTERANCE ((WINBIO_BIOMETRIC_SUBTYPE)32)
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#if (NTDDI_VERSION >= NTDDI_WIN10_RS2)
///////////////////////////////////////////////////////////////////////////////
//
// Validation header placed at the beginning of every secure buffer.
//
///////////////////////////////////////////////////////////////////////////////
typedef struct _WINBIO_SECURE_BUFFER_HEADER_V1 {
ULONG Type; // WINBIO_SECURE_BUFFER_TYPE_V1
ULONG Size; // sizeof(this structure)
ULONG Flags; // Buffer creator must set to zero
ULONGLONG ValidationTag; // Buffer creator must set
} WINBIO_SECURE_BUFFER_HEADER_V1, *PWINBIO_SECURE_BUFFER_HEADER_V1;
#define WINBIO_SECURE_BUFFER_TYPE_V1 ((ULONG)0xB9BE0001)
#endif // NTDDI_VERSION >= NTDDI_WIN10_RS2
//
// Sensor pool type identifiers
//
typedef ULONG WINBIO_POOL_TYPE, *PWINBIO_POOL_TYPE;
#define WINBIO_POOL_UNKNOWN ((WINBIO_POOL_TYPE)0)
#define WINBIO_POOL_SYSTEM ((WINBIO_POOL_TYPE)1)
#define WINBIO_POOL_PRIVATE ((WINBIO_POOL_TYPE)2)
#define WINBIO_POOL_UNASSIGNED ((WINBIO_POOL_TYPE)3) // Reserved for Microsoft - do not use.
//
// Specific access rights for Biometric Units
//
#define BIO_UNIT_RAW ((USHORT)0x0001)
#define BIO_UNIT_MAINTENANCE ((USHORT)0x0002)
#define BIO_UNIT_OPEN_SESSION ((USHORT)0x0004)
#define BIO_UNIT_EXTENDED_ACCESS ((USHORT)0x0008)
#define BIO_UNIT_ENROLL ((USHORT)0x0010)
#if (NTDDI_VERSION >= NTDDI_WIN9)
#define BIO_UNIT_DELETE_TEMPLATE ((USHORT)0x0020)
#define BIO_UNIT_CONTROL_UNIT ((USHORT)0x0040)
#endif // (NTDDI_VERSION >= NTDDI_WIN9)
//
// OpenSession parameter that controls session attributes...
//
typedef ULONG WINBIO_SESSION_FLAGS, *PWINBIO_SESSION_FLAGS;
//
// Sensor configuration flags...
//
#define WINBIO_FLAG_DEFAULT ((WINBIO_SESSION_FLAGS)0x00000000)
#define WINBIO_FLAG_BASIC ((WINBIO_SESSION_FLAGS)((WINBIO_SENSOR_BASIC_MODE & 0xFFFF)<<16))
#define WINBIO_FLAG_ADVANCED ((WINBIO_SESSION_FLAGS)((WINBIO_SENSOR_ADVANCED_MODE & 0xFFFF)<<16))
//
// Desired access flags...
//
#define WINBIO_FLAG_RAW ((WINBIO_SESSION_FLAGS)BIO_UNIT_RAW)
#define WINBIO_FLAG_MAINTENANCE ((WINBIO_SESSION_FLAGS)BIO_UNIT_MAINTENANCE)
//
// Well-known database IDs used by WinBioOpenSession
//
#define WINBIO_DB_DEFAULT ((GUID *)1)
#define WINBIO_DB_BOOTSTRAP ((GUID *)2)
#define WINBIO_DB_ONCHIP ((GUID *)3)
//
// Identify one of the components in a Biometric Unit's
// processing pipeline (for ControlUnit operations)...
//
typedef ULONG WINBIO_COMPONENT, *PWINBIO_COMPONENT;
#define WINBIO_COMPONENT_SENSOR ((WINBIO_COMPONENT)1)
#define WINBIO_COMPONENT_ENGINE ((WINBIO_COMPONENT)2)
#define WINBIO_COMPONENT_STORAGE ((WINBIO_COMPONENT)3)
//
// Event Monitor stuff...
//
typedef ULONG WINBIO_EVENT_TYPE, *PWINBIO_EVENT_TYPE;
#ifdef MIDL_PASS
//
// Generic events
//
const WINBIO_EVENT_TYPE WINBIO_EVENT_ERROR = (WINBIO_EVENT_TYPE)0xFFFFFFFF;
//
// Fingerprint events.
//
const WINBIO_EVENT_TYPE WINBIO_EVENT_FP_UNCLAIMED = (WINBIO_EVENT_TYPE)0x00000001;
const WINBIO_EVENT_TYPE WINBIO_EVENT_FP_UNCLAIMED_IDENTIFY = (WINBIO_EVENT_TYPE)0x00000002;
typedef union switch(WINBIO_EVENT_TYPE Type) _WINBIO_EVENT {
case WINBIO_EVENT_FP_UNCLAIMED: struct {
WINBIO_UNIT_ID UnitId;
WINBIO_REJECT_DETAIL RejectDetail;
} Unclaimed;
case WINBIO_EVENT_FP_UNCLAIMED_IDENTIFY: struct {
WINBIO_UNIT_ID UnitId;
WINBIO_IDENTITY Identity;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
WINBIO_REJECT_DETAIL RejectDetail;
} UnclaimedIdentify;
case WINBIO_EVENT_ERROR: struct {
HRESULT ErrorCode;
} Error;
} WINBIO_EVENT, *PWINBIO_EVENT;
#else // MIDL_PASS
//
// Generic events
//
#define WINBIO_EVENT_ERROR ((WINBIO_EVENT_TYPE)0xFFFFFFFF)
//
// Fingerprint events.
//
#define WINBIO_EVENT_FP_UNCLAIMED ((WINBIO_EVENT_TYPE)0x00000001)
#define WINBIO_EVENT_FP_UNCLAIMED_IDENTIFY ((WINBIO_EVENT_TYPE)0x00000002)
//
// Event structure passed back to applications.
//
typedef struct _WINBIO_EVENT {
WINBIO_EVENT_TYPE Type;
union {
struct {
WINBIO_UNIT_ID UnitId;
WINBIO_REJECT_DETAIL RejectDetail;
} Unclaimed;
struct {
WINBIO_UNIT_ID UnitId;
WINBIO_IDENTITY Identity;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
WINBIO_REJECT_DETAIL RejectDetail;
} UnclaimedIdentify;
struct {
HRESULT ErrorCode;
} Error;
} Parameters;
} WINBIO_EVENT, *PWINBIO_EVENT;
#endif // MIDL_PASS
#if (NTDDI_VERSION >= NTDDI_WIN9)
//
// Tickets used by data protection and credential release APIs
//
typedef ULONG64 WINBIO_PROTECTION_TICKET, *PWINBIO_PROTECTION_TICKET;
#endif // (NTDDI_VERSION >= NTDDI_WIN9)
#define WINBIO_OPAQUE_ENGINE_DATA_ITEM_COUNT ((ULONG)77) // Number of ULONG slots in the array
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
///////////////////////////////////////////////////////////////////////////////
//
// Items required by the presence-monitoring components
//
///////////////////////////////////////////////////////////////////////////////
//
// Types of presence-change events recognized by WinBio
//
typedef ULONG WINBIO_PRESENCE_CHANGE, *PWINBIO_PRESENCE_CHANGE;
#define WINBIO_PRESENCE_CHANGE_TYPE_UNKNOWN ((WINBIO_PRESENCE_CHANGE)0)
#define WINBIO_PRESENCE_CHANGE_TYPE_UPDATE_ALL ((WINBIO_PRESENCE_CHANGE)1)
#define WINBIO_PRESENCE_CHANGE_TYPE_ARRIVE ((WINBIO_PRESENCE_CHANGE)2)
#define WINBIO_PRESENCE_CHANGE_TYPE_RECOGNIZE ((WINBIO_PRESENCE_CHANGE)3)
#define WINBIO_PRESENCE_CHANGE_TYPE_DEPART ((WINBIO_PRESENCE_CHANGE)4)
#define WINBIO_PRESENCE_CHANGE_TYPE_TRACK ((WINBIO_PRESENCE_CHANGE)5)
#ifdef MIDL_PASS
//
// Factor-specific extended information about a single presence
//
typedef [switch_type(WINBIO_BIOMETRIC_TYPE)] union _WINBIO_PRESENCE_PROPERTIES {
[case(WINBIO_NO_TYPE_AVAILABLE)]
ULONG32 Null;
[case(WINBIO_TYPE_FACIAL_FEATURES)]
struct {
RECT BoundingBox;
LONG Distance;
struct {
WINBIO_UUID AdapterId;
ULONG Data[WINBIO_OPAQUE_ENGINE_DATA_ITEM_COUNT];
} OpaqueEngineData;
// [...] other face-specific properties
} FacialFeatures;
[case(WINBIO_TYPE_IRIS)]
struct {
RECT EyeBoundingBox_1;
RECT EyeBoundingBox_2;
POINT PupilCenter_1;
POINT PupilCenter_2;
LONG Distance;
} Iris;
} WINBIO_PRESENCE_PROPERTIES, *PWINBIO_PRESENCE_PROPERTIES;
//
// A single individual...
//
typedef struct _WINBIO_PRESENCE {
WINBIO_BIOMETRIC_TYPE Factor;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
HRESULT Status;
WINBIO_REJECT_DETAIL RejectDetail;
WINBIO_IDENTITY Identity;
ULONGLONG TrackingId;
WINBIO_PROTECTION_TICKET Ticket;
[switch_is(Factor)] WINBIO_PRESENCE_PROPERTIES Properties;
struct {
ULONG Size;
UCHAR Data[32];
} Authorization;
} WINBIO_PRESENCE, *PWINBIO_PRESENCE;
#else // MIDL_PASS
typedef union _WINBIO_PRESENCE_PROPERTIES {
struct {
RECT BoundingBox;
LONG Distance;
struct {
WINBIO_UUID AdapterId;
ULONG Data[WINBIO_OPAQUE_ENGINE_DATA_ITEM_COUNT];
} OpaqueEngineData;
// [...] other face-specific properties
} FacialFeatures;
struct {
RECT EyeBoundingBox_1;
RECT EyeBoundingBox_2;
POINT PupilCenter_1;
POINT PupilCenter_2;
LONG Distance;
} Iris;
/*
struct {
WINBIO_COORDINATES Location;
// [...] other voice-specific properties
} Voice;
*/
} WINBIO_PRESENCE_PROPERTIES, *PWINBIO_PRESENCE_PROPERTIES;
typedef struct _WINBIO_PRESENCE {
WINBIO_BIOMETRIC_TYPE Factor;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
HRESULT Status;
WINBIO_REJECT_DETAIL RejectDetail;
WINBIO_IDENTITY Identity;
ULONGLONG TrackingId;
WINBIO_PROTECTION_TICKET Ticket;
WINBIO_PRESENCE_PROPERTIES Properties;
struct {
ULONG Size;
UCHAR Data[32];
} Authorization;
} WINBIO_PRESENCE, *PWINBIO_PRESENCE;
#endif // MIDL_PASS
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
///////////////////////////////////////////////////////////////////////////////
//
// Schemata returned by enumeration APIs...
//
///////////////////////////////////////////////////////////////////////////////
//
// Results from EnumServiceProviders...
//
typedef struct _WINBIO_BSP_SCHEMA {
WINBIO_BIOMETRIC_TYPE BiometricFactor;
WINBIO_UUID BspId;
WINBIO_STRING Description;
WINBIO_STRING Vendor;
WINBIO_VERSION Version;
} WINBIO_BSP_SCHEMA, *PWINBIO_BSP_SCHEMA;
//
// Results from EnumBiometricUnits...
//
typedef struct _WINBIO_UNIT_SCHEMA {
WINBIO_UNIT_ID UnitId;
WINBIO_POOL_TYPE PoolType;
WINBIO_BIOMETRIC_TYPE BiometricFactor;
WINBIO_BIOMETRIC_SENSOR_SUBTYPE SensorSubType;
WINBIO_CAPABILITIES Capabilities;
WINBIO_STRING DeviceInstanceId;
WINBIO_STRING Description;
WINBIO_STRING Manufacturer;
WINBIO_STRING Model;
WINBIO_STRING SerialNumber;
WINBIO_VERSION FirmwareVersion;
} WINBIO_UNIT_SCHEMA, *PWINBIO_UNIT_SCHEMA;
///////////////////////////////////////////////////////////////////////////////
//
// Definitions for the 'Attributes' database value...
//
///////////////////////////////////////////////////////////////////////////////
#define WINBIO_DATABASE_TYPE_MASK ((ULONG)0x0000FFFF)
//
// Type values...
//
#define WINBIO_DATABASE_TYPE_FILE ((ULONG)0x00000001)
#define WINBIO_DATABASE_TYPE_DBMS ((ULONG)0x00000002)
#define WINBIO_DATABASE_TYPE_ONCHIP ((ULONG)0x00000003)
#define WINBIO_DATABASE_TYPE_SMARTCARD ((ULONG)0x00000004)
#define WINBIO_DATABASE_FLAG_MASK ((ULONG)0xFFFF0000)
//
// Flag values...
//
#define WINBIO_DATABASE_FLAG_REMOVABLE ((ULONG)0x00010000)
#define WINBIO_DATABASE_FLAG_REMOTE ((ULONG)0x00020000)
//
// Results from EnumDatabases...
//
typedef struct _WINBIO_STORAGE_SCHEMA {
WINBIO_BIOMETRIC_TYPE BiometricFactor;
WINBIO_UUID DatabaseId;
WINBIO_UUID DataFormat;
ULONG Attributes;
WINBIO_STRING FilePath;
WINBIO_STRING ConnectionString;
} WINBIO_STORAGE_SCHEMA, *PWINBIO_STORAGE_SCHEMA;
///////////////////////////////////////////////////////////////////////////////
//
// Bit flags for WinBio framework change notification...
//
typedef ULONG WINBIO_FRAMEWORK_CHANGE_TYPE, *PWINBIO_FRAMEWORK_CHANGE_TYPE;
#define WINBIO_FRAMEWORK_CHANGE_UNIT ((WINBIO_FRAMEWORK_CHANGE_TYPE)0x00000001)
#if (NTDDI_VERSION >= NTDDI_WIN10_RS2)
#define WINBIO_FRAMEWORK_CHANGE_UNIT_STATUS ((WINBIO_FRAMEWORK_CHANGE_TYPE)0x00000002)
#endif // NTDDI_VERSION >= NTDDI_WIN10_RS2
///////////////////////////////////////////////////////////////////////////////
//
// Maximum number of bytes in a single capture...
//
#ifdef MIDL_PASS
const ULONG WINBIO_MAX_SAMPLE_BUFFER_SIZE = 0x7FFFFFFF;
#else // MIDL_PASS
#define WINBIO_MAX_SAMPLE_BUFFER_SIZE ((ULONG)0x7FFFFFFF)
#endif // MIDL_PASS
///////////////////////////////////////////////////////////////////////////////
//
// Results of asynchronous operations...
//
///////////////////////////////////////////////////////////////////////////////
//
// Enumeration specifying what kind of operation is being completed...
//
typedef ULONG WINBIO_OPERATION_TYPE, *PWINBIO_OPERATION_TYPE;
//
// Session-based operations...
//
#define WINBIO_OPERATION_NONE ((WINBIO_OPERATION_TYPE)0)
#define WINBIO_OPERATION_OPEN ((WINBIO_OPERATION_TYPE)1)
#define WINBIO_OPERATION_CLOSE ((WINBIO_OPERATION_TYPE)2)
#define WINBIO_OPERATION_VERIFY ((WINBIO_OPERATION_TYPE)3)
#define WINBIO_OPERATION_IDENTIFY ((WINBIO_OPERATION_TYPE)4)
#define WINBIO_OPERATION_LOCATE_SENSOR ((WINBIO_OPERATION_TYPE)5)
#define WINBIO_OPERATION_ENROLL_BEGIN ((WINBIO_OPERATION_TYPE)6)
#define WINBIO_OPERATION_ENROLL_CAPTURE ((WINBIO_OPERATION_TYPE)7)
#define WINBIO_OPERATION_ENROLL_COMMIT ((WINBIO_OPERATION_TYPE)8)
#define WINBIO_OPERATION_ENROLL_DISCARD ((WINBIO_OPERATION_TYPE)9)
#define WINBIO_OPERATION_ENUM_ENROLLMENTS ((WINBIO_OPERATION_TYPE)10)
#define WINBIO_OPERATION_DELETE_TEMPLATE ((WINBIO_OPERATION_TYPE)11)
#define WINBIO_OPERATION_CAPTURE_SAMPLE ((WINBIO_OPERATION_TYPE)12)
#define WINBIO_OPERATION_GET_PROPERTY ((WINBIO_OPERATION_TYPE)13)
#define WINBIO_OPERATION_SET_PROPERTY ((WINBIO_OPERATION_TYPE)14)
#define WINBIO_OPERATION_GET_EVENT ((WINBIO_OPERATION_TYPE)15)
#define WINBIO_OPERATION_LOCK_UNIT ((WINBIO_OPERATION_TYPE)16)
#define WINBIO_OPERATION_UNLOCK_UNIT ((WINBIO_OPERATION_TYPE)17)
#define WINBIO_OPERATION_CONTROL_UNIT ((WINBIO_OPERATION_TYPE)18)
#define WINBIO_OPERATION_CONTROL_UNIT_PRIVILEGED ((WINBIO_OPERATION_TYPE)19)
//
// Framework operations...
//
#define WINBIO_OPERATION_OPEN_FRAMEWORK ((WINBIO_OPERATION_TYPE)20)
#define WINBIO_OPERATION_CLOSE_FRAMEWORK ((WINBIO_OPERATION_TYPE)21)
#define WINBIO_OPERATION_ENUM_SERVICE_PROVIDERS ((WINBIO_OPERATION_TYPE)22)
#define WINBIO_OPERATION_ENUM_BIOMETRIC_UNITS ((WINBIO_OPERATION_TYPE)23)
#define WINBIO_OPERATION_ENUM_DATABASES ((WINBIO_OPERATION_TYPE)24)
#define WINBIO_OPERATION_UNIT_ARRIVAL ((WINBIO_OPERATION_TYPE)25)
#define WINBIO_OPERATION_UNIT_REMOVAL ((WINBIO_OPERATION_TYPE)26)
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// Things related to get/set property operations
//
typedef ULONG32 WINBIO_PROPERTY_TYPE, *PWINBIO_PROPERTY_TYPE;
#define WINBIO_PROPERTY_TYPE_SESSION ((WINBIO_PROPERTY_TYPE)1)
#define WINBIO_PROPERTY_TYPE_UNIT ((WINBIO_PROPERTY_TYPE)2)
#define WINBIO_PROPERTY_TYPE_TEMPLATE ((WINBIO_PROPERTY_TYPE)3)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
#define WINBIO_PROPERTY_TYPE_ACCOUNT ((WINBIO_PROPERTY_TYPE)4)
#ifdef MIDL_PASS
//
// Limit the size of an ingoing property buffer for the server
//
const ULONG WINBIO_MAX_SET_PROPERTY_BUFFER_SIZE = 0x1000;
#else // MIDL_PASS
#define WINBIO_MAX_SET_PROPERTY_BUFFER_SIZE ((ULONG)0x1000)
#endif // MIDL_PASS
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
typedef ULONG32 WINBIO_PROPERTY_ID, *PWINBIO_PROPERTY_ID;
///////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_TYPE_SESSION properties...
//
///////////////////////////////////////////////////////////////////////////
//
// (None)
//
///////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_TYPE_UNIT properties...
//
///////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_SAMPLE_HINT
//
// Description:
// Estimate of the maximum number of good biometric
// samples required to complete an enrollment template.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a ULONG buffer containing the hint
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(ULONG)
//
#define WINBIO_PROPERTY_SAMPLE_HINT ((WINBIO_PROPERTY_ID)1)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_EXTENDED_SENSOR_INFO
//
// Description:
// Returns extended information about the capabilities
// and attributes of the Sensor component connected to
// a specific biometric unit.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a buffer containing a WINBIO_EXTENDED_SENSOR_INFO structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_EXTENDED_SENSOR_INFO)
//
#define WINBIO_PROPERTY_EXTENDED_SENSOR_INFO ((WINBIO_PROPERTY_ID)2)
//
// Enumeration for mandatory orientation...
//
typedef ULONG WINBIO_ORIENTATION, *PWINBIO_ORIENTATION;
#define WINBIO_ORIENTATION_UNSPECIFIED ((WINBIO_ORIENTATION)0)
#define WINBIO_ORIENTATION_LANDSCAPE ((WINBIO_ORIENTATION)1)
#define WINBIO_ORIENTATION_PORTRAIT ((WINBIO_ORIENTATION)2)
#define WINBIO_ORIENTATION_ANY ((WINBIO_ORIENTATION)3)
#ifdef MIDL_PASS
//
// Factor-specific extended information about a single adapter
//
typedef struct _WINBIO_EXTENDED_SENSOR_INFO {
WINBIO_CAPABILITIES GenericSensorCapabilities;
WINBIO_BIOMETRIC_TYPE Factor;
[switch_is(Factor)] union
{
[case(WINBIO_NO_TYPE_AVAILABLE)]
ULONG32 Null;
[case(WINBIO_TYPE_FACIAL_FEATURES)]
struct {
RECT FrameSize; // Camera frame size, in pixels; (top, left) fields always (0,0)
POINT FrameOffset; // Offset of face camera frame from video camera, in pixels. (0, 0) indicates complete overlap
WINBIO_ORIENTATION MandatoryOrientation;
struct {
WCHAR ColorSensorId[260];
WCHAR InfraredSensorId[260];
UINT32 InfraredSensorRotationAngle;
} HardwareInfo;
} FacialFeatures;
[case(WINBIO_TYPE_FINGERPRINT)]
struct {
ULONG32 Reserved; // Reserved for future expansion
} Fingerprint;
[case(WINBIO_TYPE_IRIS)]
struct {
RECT FrameSize; // Iris camera frame size, in pixels; (top, left) fields always (0,0)
POINT FrameOffset; // Offset of iris camera frame from video camera, in pixels. (0, 0) indicates complete overlap
WINBIO_ORIENTATION MandatoryOrientation;
} Iris;
[case(WINBIO_TYPE_VOICE)]
struct {
ULONG32 Reserved; // Reserved for future expansion
} Voice;
} Specific;
} WINBIO_EXTENDED_SENSOR_INFO, *PWINBIO_EXTENDED_SENSOR_INFO;
#else // MIDL_PASS
typedef struct _WINBIO_EXTENDED_SENSOR_INFO {
WINBIO_CAPABILITIES GenericSensorCapabilities;
WINBIO_BIOMETRIC_TYPE Factor;
union
{
ULONG32 Null;
struct {
RECT FrameSize; // Camera frame size, in pixels; (top, left) fields always (0,0)
POINT FrameOffset; // Offset of face camera frame from video camera, in pixels. (0, 0) indicates complete overlap
WINBIO_ORIENTATION MandatoryOrientation;
struct {
WCHAR ColorSensorId[260];
WCHAR InfraredSensorId[260];
UINT32 InfraredSensorRotationAngle;
} HardwareInfo;
} FacialFeatures;
struct {
ULONG32 Reserved; // Reserved for future expansion
} Fingerprint;
struct {
RECT FrameSize; // Iris camera frame size, in pixels; (top, left) fields always (0,0)
POINT FrameOffset; // Offset of iris camera frame from video camera, in pixels. (0, 0) indicates complete overlap
WINBIO_ORIENTATION MandatoryOrientation;
} Iris;
struct {
ULONG32 Reserved; // Reserved for future expansion
} Voice;
} Specific;
} WINBIO_EXTENDED_SENSOR_INFO, *PWINBIO_EXTENDED_SENSOR_INFO;
#endif // MIDL_PASS
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_EXTENDED_ENGINE_INFO
//
// Description:
// Returns extended information about the capabilities
// and attributes of the Engine component connected to
// a specific biometric unit.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a buffer containing a WINBIO_EXTENDED_ENGINE_INFO structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_EXTENDED_ENGINE_INFO)
//
#define WINBIO_PROPERTY_EXTENDED_ENGINE_INFO ((WINBIO_PROPERTY_ID)3)
//
// Generic Engine Capabilities
//
#define WINBIO_ENG_CAP_ITERATIVE_IMPROVEMENT ((WINBIO_CAPABILITIES)0x00000001)
#define WINBIO_ENG_CAP_SPOOF_DETECTION ((WINBIO_CAPABILITIES)0x00000002)
#ifdef MIDL_PASS
typedef struct _WINBIO_EXTENDED_ENGINE_INFO {
WINBIO_CAPABILITIES GenericEngineCapabilities;
WINBIO_BIOMETRIC_TYPE Factor;
[switch_is(Factor)] union
{
[case(WINBIO_NO_TYPE_AVAILABLE)]
ULONG32 Null;
[case(WINBIO_TYPE_FACIAL_FEATURES)]
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG32 Null;
} EnrollmentRequirements;
} FacialFeatures;
[case(WINBIO_TYPE_FINGERPRINT)]
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG GeneralSamples;
ULONG Center;
ULONG TopEdge;
ULONG BottomEdge;
ULONG LeftEdge;
ULONG RightEdge;
} EnrollmentRequirements;
} Fingerprint;
[case(WINBIO_TYPE_IRIS)]
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG32 Null;
} EnrollmentRequirements;
} Iris;
[case(WINBIO_TYPE_VOICE)]
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG32 Null;
} EnrollmentRequirements;
} Voice;
} Specific;
} WINBIO_EXTENDED_ENGINE_INFO, *PWINBIO_EXTENDED_ENGINE_INFO;
#else // MIDL_PASS
typedef struct _WINBIO_EXTENDED_ENGINE_INFO {
WINBIO_CAPABILITIES GenericEngineCapabilities;
WINBIO_BIOMETRIC_TYPE Factor;
union
{
ULONG32 Null;
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG32 Null;
} EnrollmentRequirements;
} FacialFeatures;
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG GeneralSamples;
ULONG Center;
ULONG TopEdge;
ULONG BottomEdge;
ULONG LeftEdge;
ULONG RightEdge;
} EnrollmentRequirements;
} Fingerprint;
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG32 Null;
} EnrollmentRequirements;
} Iris;
struct {
WINBIO_CAPABILITIES Capabilities; // Reserved for future expansion
struct {
ULONG32 Null;
} EnrollmentRequirements;
} Voice;
} Specific;
} WINBIO_EXTENDED_ENGINE_INFO, *PWINBIO_EXTENDED_ENGINE_INFO;
#endif // MIDL_PASS
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_EXTENDED_STORAGE_INFO
//
// Description:
// Returns extended information about the capabilities
// and attributes of the Storage component connected to
// a specific biometric unit.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a buffer containing a WINBIO_EXTENDED_STORAGE_INFO structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_EXTENDED_STORAGE_INFO)
//
#define WINBIO_PROPERTY_EXTENDED_STORAGE_INFO ((WINBIO_PROPERTY_ID)4)
#ifdef MIDL_PASS
typedef struct _WINBIO_EXTENDED_STORAGE_INFO {
WINBIO_CAPABILITIES GenericStorageCapabilities;
WINBIO_BIOMETRIC_TYPE Factor;
[switch_is(Factor)] union
{
[case(WINBIO_NO_TYPE_AVAILABLE)]
ULONG32 Null;
[case(WINBIO_TYPE_FACIAL_FEATURES)]
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} FacialFeatures;
[case(WINBIO_TYPE_FINGERPRINT)]
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} Fingerprint;
[case(WINBIO_TYPE_IRIS)]
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} Iris;
[case(WINBIO_TYPE_VOICE)]
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} Voice;
} Specific;
} WINBIO_EXTENDED_STORAGE_INFO, *PWINBIO_EXTENDED_STORAGE_INFO;
#else // MIDL_PASS
typedef struct _WINBIO_EXTENDED_STORAGE_INFO {
WINBIO_CAPABILITIES GenericStorageCapabilities;
WINBIO_BIOMETRIC_TYPE Factor;
union
{
ULONG32 Null;
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} FacialFeatures;
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} Fingerprint;
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} Iris;
struct {
WINBIO_CAPABILITIES Capabilities;
// Reserved for future expansion
} Voice;
} Specific;
} WINBIO_EXTENDED_STORAGE_INFO, *PWINBIO_EXTENDED_STORAGE_INFO;
#endif // MIDL_PASS
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_EXTENDED_ENROLLMENT_STATUS
//
// Description:
// Returns extended information about the status of an
// in-progress enrollment on a particular biometric unit.
// If no enrollment is in progress on the BU, it returns
// WINBIO_E_INVALID_OPERATION in the 'TemplateStatus' field.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a buffer containing a WINBIO_EXTENDED_ENROLLMENT_STATUS structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_EXTENDED_ENROLLMENT_STATUS)
//
#define WINBIO_PROPERTY_EXTENDED_ENROLLMENT_STATUS ((WINBIO_PROPERTY_ID)5)
#ifdef MIDL_PASS
typedef struct _WINBIO_EXTENDED_ENROLLMENT_STATUS {
HRESULT TemplateStatus;
WINBIO_REJECT_DETAIL RejectDetail;
ULONG PercentComplete;
WINBIO_BIOMETRIC_TYPE Factor;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
[switch_is(Factor)] union
{
[case(WINBIO_NO_TYPE_AVAILABLE)]
ULONG32 Null;
[case(WINBIO_TYPE_FACIAL_FEATURES)]
struct {
RECT BoundingBox;
LONG Distance;
struct {
WINBIO_UUID AdapterId;
ULONG Data[WINBIO_OPAQUE_ENGINE_DATA_ITEM_COUNT];
} OpaqueEngineData;
} FacialFeatures;
[case(WINBIO_TYPE_FINGERPRINT)]
struct {
ULONG GeneralSamples;
ULONG Center;
ULONG TopEdge;
ULONG BottomEdge;
ULONG LeftEdge;
ULONG RightEdge;
} Fingerprint;
[case(WINBIO_TYPE_IRIS)]
struct {
RECT EyeBoundingBox_1;
RECT EyeBoundingBox_2;
POINT PupilCenter_1;
POINT PupilCenter_2;
LONG Distance;
ULONG GridPointCompletionPercent;
UINT16 GridPointIndex;
struct
{
double X;
double Y;
double Z;
} Point3D;
BOOL StopCaptureAndShowCriticalFeedback;
} Iris;
[case(WINBIO_TYPE_VOICE)]
struct {
ULONG32 Reserved; // Reserved for future expansion
} Voice;
} Specific;
} WINBIO_EXTENDED_ENROLLMENT_STATUS, *PWINBIO_EXTENDED_ENROLLMENT_STATUS;
#else // MIDL_PASS
typedef struct _WINBIO_EXTENDED_ENROLLMENT_STATUS {
HRESULT TemplateStatus;
WINBIO_REJECT_DETAIL RejectDetail;
ULONG PercentComplete;
WINBIO_BIOMETRIC_TYPE Factor;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
union
{
ULONG32 Null;
struct {
RECT BoundingBox;
LONG Distance;
struct {
WINBIO_UUID AdapterId;
ULONG Data[WINBIO_OPAQUE_ENGINE_DATA_ITEM_COUNT];
} OpaqueEngineData;
} FacialFeatures;
struct {
ULONG GeneralSamples;
ULONG Center;
ULONG TopEdge;
ULONG BottomEdge;
ULONG LeftEdge;
ULONG RightEdge;
} Fingerprint;
struct {
RECT EyeBoundingBox_1;
RECT EyeBoundingBox_2;
POINT PupilCenter_1;
POINT PupilCenter_2;
LONG Distance;
ULONG GridPointCompletionPercent;
UINT16 GridPointIndex;
struct
{
double X;
double Y;
double Z;
} Point3D;
BOOL StopCaptureAndShowCriticalFeedback;
} Iris;
struct {
ULONG32 Reserved; // Reserved for future expansion
} Voice;
} Specific;
} WINBIO_EXTENDED_ENROLLMENT_STATUS, *PWINBIO_EXTENDED_ENROLLMENT_STATUS;
#endif // MIDL_PASS
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_EXTENDED_UNIT_STATUS
//
// Description:
// Returns extended information about the current status
// of a specific biometric unit.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a buffer containing a WINBIO_EXTENDED_UNIT_STATUS structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_EXTENDED_UNIT_STATUS)
//
#define WINBIO_PROPERTY_EXTENDED_UNIT_STATUS ((WINBIO_PROPERTY_ID)6)
typedef struct _WINBIO_EXTENDED_UNIT_STATUS {
WINBIO_SENSOR_STATUS Availability;
ULONG ReasonCode;
} WINBIO_EXTENDED_UNIT_STATUS, *PWINBIO_EXTENDED_UNIT_STATUS;
#if (NTDDI_VERSION >= NTDDI_WIN10_RS5)
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_UNIT_SECURITY_LEVEL
//
// Description:
// Returns the security level a specific biometric unit
// is running as.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be valid
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a WINBIO_UNIT_SECURITY_LEVEL buffer containing the level
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_UNIT_SECURITY_LEVEL)
//
#define WINBIO_PROPERTY_UNIT_SECURITY_LEVEL ((WINBIO_PROPERTY_ID)7)
#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS5)
#if (NTDDI_VERSION >= NTDDI_WIN10_19H1)
///////////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_FP_BU_STATE
//
// Description:
// Returns information on whether a FP sensor is currently
// attached to the machine, in addition to any relevant FP
// biometric unit (BU) creation error codes.
//
// Access:
// Read-only
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be zero
// Identity - must be NULL
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to buffer containing a WINBIO_FP_BU_STATE structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_FP_BU_STATE)
//
#define WINBIO_PROPERTY_FP_BU_STATE ((WINBIO_PROPERTY_ID)8)
typedef struct _WINBIO_FP_BU_STATE {
BOOL SensorAttached;
HRESULT CreationResult;
} WINBIO_FP_BU_STATE, *PWINBIO_FP_BU_STATE;
#endif // (NTDDI_VERSION >= NTDDI_WIN10_19H1)
///////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_TYPE_TEMPLATE properties...
//
///////////////////////////////////////////////////////////////////////////
//
// (None)
//
///////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_TYPE_ACCOUNT properties...
//
///////////////////////////////////////////////////////////////////////////
//
// WINBIO_PROPERTY_ANTI_SPOOF_POLICY
//
// Description:
// Gets or sets the values of the anti-spoofing policy for a
// specific user account.
//
// Performing a 'Get' operation with the wildcard identity returns
// the system default value of this policy.
//
// Access:
// Read/Write
//
// Non-privileged users can only modify their own policy setting. If
// the 'Identity' argument refers to another account -- or contains a
// wildcard identifier value -- WinBioSetProperty will fail.
//
// Inputs:
// SessionHandle - must be valid
// UnitId - must be zero
// Identity - account SID to be queried or changed. If NULL, the
// SID associated with SessionHandle will be used.
// SubFactor - must be WINBIO_SUBTYPE_NO_INFORMATION
//
// Outputs:
// PropertyBuffer - points to a buffer containing a WINBIO_ANTI_SPOOF_POLICY structure
// PropertyBufferSize - points to a SIZE_T variable containing sizeof(WINBIO_ANTI_SPOOF_POLICY)
//
#define WINBIO_PROPERTY_ANTI_SPOOF_POLICY ((WINBIO_PROPERTY_ID)1)
typedef enum _WINBIO_ANTI_SPOOF_POLICY_ACTION
{
WINBIO_ANTI_SPOOF_DISABLE = 0x00000000,
WINBIO_ANTI_SPOOF_ENABLE = 0x00000001,
WINBIO_ANTI_SPOOF_REMOVE = 0x00000002,
} WINBIO_ANTI_SPOOF_POLICY_ACTION, *PWINBIO_ANTI_SPOOF_POLICY_ACTION;
typedef enum _WINBIO_POLICY_SOURCE
{
WINBIO_POLICY_UNKNOWN = 0x00000000,
WINBIO_POLICY_DEFAULT = 0x00000001,
WINBIO_POLICY_LOCAL = 0x00000002,
WINBIO_POLICY_ADMIN = 0x00000003,
} WINBIO_POLICY_SOURCE, *PWINBIO_POLICY_SOURCE;
typedef struct _WINBIO_ANTI_SPOOF_POLICY {
WINBIO_ANTI_SPOOF_POLICY_ACTION Action;
WINBIO_POLICY_SOURCE Source;
} WINBIO_ANTI_SPOOF_POLICY, *PWINBIO_ANTI_SPOOF_POLICY;
#if (NTDDI_VERSION >= NTDDI_WIN9)
///////////////////////////////////////////////////////////////////////////////
//
// Async ticket operations...
//
///////////////////////////////////////////////////////////////////////////////
#define WINBIO_OPERATION_IDENTIFY_AND_RELEASE_TICKET ((WINBIO_OPERATION_TYPE)27)
#define WINBIO_OPERATION_VERIFY_AND_RELEASE_TICKET ((WINBIO_OPERATION_TYPE)28)
#endif // (NTDDI_VERSION >= NTDDI_WIN9)
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
///////////////////////////////////////////////////////////////////////////////
//
// Facial features operations...
//
///////////////////////////////////////////////////////////////////////////////
#define WINBIO_OPERATION_MONITOR_PRESENCE ((WINBIO_OPERATION_TYPE)29)
#define WINBIO_OPERATION_ENROLL_SELECT ((WINBIO_OPERATION_TYPE)30)
#endif // (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
///////////////////////////////////////////////////////////////////////////////
//
// Credential management
//
///////////////////////////////////////////////////////////////////////////////
typedef enum _WINBIO_CREDENTIAL_TYPE
{
WINBIO_CREDENTIAL_PASSWORD = 0x00000001,
WINBIO_CREDENTIAL_ALL = 0xffffffff,
} WINBIO_CREDENTIAL_TYPE;
typedef enum _WINBIO_CREDENTIAL_FORMAT
{
WINBIO_PASSWORD_GENERIC = 0x00000001,
WINBIO_PASSWORD_PACKED = 0x00000002,
WINBIO_PASSWORD_PROTECTED = 0x00000003,
} WINBIO_CREDENTIAL_FORMAT;
typedef enum _WINBIO_CREDENTIAL_STATE {
WINBIO_CREDENTIAL_NOT_SET = 0x00000001,
WINBIO_CREDENTIAL_SET = 0x00000002,
} WINBIO_CREDENTIAL_STATE, *PWINBIO_CREDENTIAL_STATE;
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
//
// Settings
//
///////////////////////////////////////////////////////////////////////////////
typedef ULONG32 WINBIO_SETTING_SOURCE_TYPE, *PWINBIO_SETTING_SOURCE_TYPE;
#define WINBIO_SETTING_SOURCE_INVALID ((WINBIO_SETTING_SOURCE_TYPE)0)
#define WINBIO_SETTING_SOURCE_DEFAULT ((WINBIO_SETTING_SOURCE_TYPE)1)
#define WINBIO_SETTING_SOURCE_POLICY ((WINBIO_SETTING_SOURCE_TYPE)2)
#define WINBIO_SETTING_SOURCE_LOCAL ((WINBIO_SETTING_SOURCE_TYPE)3)
typedef struct _WINBIO_EXTENDED_ENROLLMENT_PARAMETERS {
SIZE_T Size;
WINBIO_BIOMETRIC_SUBTYPE SubFactor;
} WINBIO_EXTENDED_ENROLLMENT_PARAMETERS, *PWINBIO_EXTENDED_ENROLLMENT_PARAMETERS;
typedef struct _WINBIO_ACCOUNT_POLICY {
WINBIO_IDENTITY Identity;
WINBIO_ANTI_SPOOF_POLICY_ACTION AntiSpoofBehavior;
} WINBIO_ACCOUNT_POLICY, *PWINBIO_ACCOUNT_POLICY;
#if (NTDDI_VERSION >= NTDDI_WIN10_RS2)
#define WINBIO_OPERATION_ENROLL_AUTHORIZE ((WINBIO_OPERATION_TYPE)31)
#define WINBIO_OPERATION_ENROLL_REVOKE ((WINBIO_OPERATION_TYPE)32)
#define WINBIO_OPERATION_GET_PROTECTION_POLICY ((WINBIO_OPERATION_TYPE)33)
typedef struct _WINBIO_PROTECTION_POLICY
{
ULONG Version;
WINBIO_IDENTITY Identity;
WINBIO_UUID DatabaseId;
ULONGLONG UserState;
SIZE_T PolicySize;
UCHAR Policy[128];
} WINBIO_PROTECTION_POLICY, *PWINBIO_PROTECTION_POLICY;
typedef ULONG32 WINBIO_MATCH_TYPE, *PWINBIO_MATCH_TYPE;
#define WINBIO_MATCH_SOFTWARE ((WINBIO_MATCH_TYPE)1)
#define WINBIO_MATCH_TRUSTED_EXECUTION_ENVIRONMENT ((WINBIO_MATCH_TYPE)2)
#define WINBIO_MATCH_ON_CHIP ((WINBIO_MATCH_TYPE)3)
typedef ULONG32 WINBIO_PROTECTION_TYPE, *PWINBIO_PROTECTION_TYPE;
#define WINBIO_PROTECTION_SOFTWARE ((WINBIO_PROTECTION_TYPE)1)
#define WINBIO_PROTECTION_TRUSTED_EXECUTION_ENVIRONMENT ((WINBIO_PROTECTION_TYPE)2)
typedef struct _WINBIO_GESTURE_METADATA
{
SIZE_T Size;
WINBIO_BIOMETRIC_TYPE BiometricType;
WINBIO_MATCH_TYPE MatchType;
WINBIO_PROTECTION_TYPE ProtectionType;
} WINBIO_GESTURE_METADATA, *PWINBIO_GESTURE_METADATA;
//
// Framework operation - async unit status update notification...
//
#define WINBIO_OPERATION_NOTIFY_UNIT_STATUS_CHANGE ((WINBIO_OPERATION_TYPE)34)
#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS2)
#if (NTDDI_VERSION >= NTDDI_WIN10_RS3)
#ifdef MIDL_PASS
//
// Limit the size of vendor-specific type info about a sensor to 4K
//
const ULONG WINBIO_MAX_PRIVATE_SENSOR_TYPE_INFO_BUFFER_SIZE = 0x1000;
#else // MIDL_PASS
#define WINBIO_MAX_PRIVATE_SENSOR_TYPE_INFO_BUFFER_SIZE ((ULONG)0x1000)
#endif // MIDL_PASS
#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS3)
#ifdef __cplusplus
} // extern "C"
#endif
#pragma warning( pop )
#endif // (NTDDI_VERSION >= NTDDI_WIN7)
#endif // _WINBIO_TYPES_H_712486DB_3EF5_41da_937A_55DCB7B66A53_