← Back to branch summary

~ubuntu-branches/ubuntu/feisty/fpc/feisty

« back to all changes in this revision

Viewing changes to packages/extra/winunits/jwaauthz.pas

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-01-27 20:08:50 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070127200850-9mrptaqqjsx9nwa7
Tags: 2.0.4-5
* Fixed Build-Depends.
* Add myself to Uploaders in debian/control.
* Make sure that the sources are really patched before building them.
* Build unit 'libc' on powerpc too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
packages/extra/winunits/jwaauthz.pas
1
 
{******************************************************************************}
2
 
{                                                                              }
3
 
{ Authorization Framework API interface Unit for Object Pascal                 }
4
 
{                                                                              }
5
 
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
6
 
{ Corporation. All Rights Reserved.                                            }
7
 
{                                                                              }
8
 
{ The original file is: authz.h, released August 2001. The original Pascal     }
9
 
{ code is: Authz.pas, released October 2001. The initial developer of the      }
10
 
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
11
 
{                                                                              }
12
 
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
13
 
{ Marcel van Brakel. All Rights Reserved.                                      }
14
 
{                                                                              }
15
 
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
16
 
{                                                                              }
17
 
{ You may retrieve the latest version of this file at the Project JEDI         }
18
 
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
19
 
{                                                                              }
20
 
{ The contents of this file are used with permission, subject to the Mozilla   }
21
 
{ Public License Version 1.1 (the "License"); you may not use this file except }
22
 
{ in compliance with the License. You may obtain a copy of the License at      }
23
 
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
24
 
{                                                                              }
25
 
{ Software distributed under the License is distributed on an "AS IS" basis,   }
26
 
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27
 
{ the specific language governing rights and limitations under the License.    }
28
 
{                                                                              }
29
 
{ Alternatively, the contents of this file may be used under the terms of the  }
30
 
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
31
 
{ provisions of the LGPL License are applicable instead of those above.        }
32
 
{ If you wish to allow use of your version of this file only under the terms   }
33
 
{ of the LGPL License and not to allow others to use your version of this file }
34
 
{ under the MPL, indicate your decision by deleting  the provisions above and  }
35
 
{ replace  them with the notice and other provisions required by the LGPL      }
36
 
{ License.  If you do not delete the provisions above, a recipient may use     }
37
 
{ your version of this file under either the MPL or the LGPL License.          }
38
 
{                                                                              }
39
 
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
40
 
{                                                                              }
41
 
{******************************************************************************}
42
 
 
43
 
// $Id: jwaauthz.pas,v 1.1 2005/04/04 07:56:10 marco Exp $
44
 
 
45
 
unit JwaAuthz;
46
 
 
47
 
{$WEAKPACKAGEUNIT}
48
 
 
49
 
{$HPPEMIT ''}
50
 
{$HPPEMIT '#include "authz.h"'}
51
 
{$HPPEMIT ''}
52
 
 
53
 
{$I jediapilib.inc}
54
 
 
55
 
interface
56
 
 
57
 
uses
58
 
  JwaWinNT, JwaWinType;
59
 
 
60
 
//
61
 
// Flags which may be used at the time of client context creation using a sid.
62
 
//
63
 
 
64
 
const
65
 
  AUTHZ_SKIP_TOKEN_GROUPS = $2;
66
 
  {$EXTERNALSYM AUTHZ_SKIP_TOKEN_GROUPS}
67
 
  AUTHZ_REQUIRE_S4U_LOGON = $4;
68
 
  {$EXTERNALSYM AUTHZ_REQUIRE_S4U_LOGON}
69
 
 
70
 
type
71
 
  AUTHZ_ACCESS_CHECK_RESULTS_HANDLE = HANDLE;
72
 
  {$EXTERNALSYM AUTHZ_ACCESS_CHECK_RESULTS_HANDLE}
73
 
  AUTHZ_CLIENT_CONTEXT_HANDLE = HANDLE;
74
 
  {$EXTERNALSYM AUTHZ_CLIENT_CONTEXT_HANDLE}
75
 
  AUTHZ_RESOURCE_MANAGER_HANDLE = HANDLE;
76
 
  {$EXTERNALSYM AUTHZ_RESOURCE_MANAGER_HANDLE}
77
 
  AUTHZ_AUDIT_EVENT_HANDLE = HANDLE;
78
 
  {$EXTERNALSYM AUTHZ_AUDIT_EVENT_HANDLE}
79
 
  AUTHZ_AUDIT_EVENT_TYPE_HANDLE = HANDLE;
80
 
  {$EXTERNALSYM AUTHZ_AUDIT_EVENT_TYPE_HANDLE}
81
 
  AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE = HANDLE;
82
 
  {$EXTERNALSYM AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE}
83
 
 
84
 
  PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE = ^AUTHZ_ACCESS_CHECK_RESULTS_HANDLE;
85
 
  {$EXTERNALSYM PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE}
86
 
  PAUTHZ_CLIENT_CONTEXT_HANDLE = ^AUTHZ_CLIENT_CONTEXT_HANDLE;
87
 
  {$EXTERNALSYM PAUTHZ_CLIENT_CONTEXT_HANDLE}
88
 
  PAUTHZ_RESOURCE_MANAGER_HANDLE = ^AUTHZ_RESOURCE_MANAGER_HANDLE;
89
 
  {$EXTERNALSYM PAUTHZ_RESOURCE_MANAGER_HANDLE}
90
 
  PAUTHZ_AUDIT_EVENT_HANDLE = ^AUTHZ_AUDIT_EVENT_HANDLE;
91
 
  {$EXTERNALSYM PAUTHZ_AUDIT_EVENT_HANDLE}
92
 
  PAUTHZ_AUDIT_EVENT_TYPE_HANDLE = ^AUTHZ_AUDIT_EVENT_TYPE_HANDLE;
93
 
  {$EXTERNALSYM PAUTHZ_AUDIT_EVENT_TYPE_HANDLE}
94
 
  PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE = ^AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE;
95
 
  {$EXTERNALSYM PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE}
96
 
 
97
 
//
98
 
// Structure defining the access check request.
99
 
//
100
 
 
101
 
  PAUTHZ_ACCESS_REQUEST = ^AUTHZ_ACCESS_REQUEST;
102
 
  {$EXTERNALSYM PAUTHZ_ACCESS_REQUEST}
103
 
  _AUTHZ_ACCESS_REQUEST = record
104
 
    DesiredAccess: ACCESS_MASK;
105
 
    //
106
 
    // To replace the principal self sid in the acl.
107
 
    //
108
 
    PrincipalSelfSid: PSID;
109
 
    //
110
 
    // Object type list represented by an array of (level, guid) pair and the
111
 
    // number of elements in the array. This is a post-fix representation of the
112
 
    // object tree.
113
 
    // These fields should be set to NULL and 0 respectively except when per
114
 
    // property access is desired.
115
 
    //
116
 
    ObjectTypeList: POBJECT_TYPE_LIST;
117
 
    ObjectTypeListLength: DWORD;
118
 
    //
119
 
    // To support completely business rules based access. This will be passed as
120
 
    // input to the callback access check function. Access check algorithm does
121
 
    // not interpret these.
122
 
    //
123
 
    OptionalArguments: PVOID;
124
 
  end;
125
 
  {$EXTERNALSYM _AUTHZ_ACCESS_REQUEST}
126
 
  AUTHZ_ACCESS_REQUEST = _AUTHZ_ACCESS_REQUEST;
127
 
  {$EXTERNALSYM AUTHZ_ACCESS_REQUEST}
128
 
  TAuthzAccessRequest = AUTHZ_ACCESS_REQUEST;
129
 
  PAuthzAccessRequest = PAUTHZ_ACCESS_REQUEST;
130
 
 
131
 
//
132
 
// Structure to return the results of the access check call.
133
 
//
134
 
 
135
 
const
136
 
  AUTHZ_GENERATE_SUCCESS_AUDIT = $1;
137
 
  {$EXTERNALSYM AUTHZ_GENERATE_SUCCESS_AUDIT}
138
 
  AUTHZ_GENERATE_FAILURE_AUDIT = $2;
139
 
  {$EXTERNALSYM AUTHZ_GENERATE_FAILURE_AUDIT}
140
 
 
141
 
type
142
 
  PAUTHZ_ACCESS_REPLY = ^AUTHZ_ACCESS_REPLY;
143
 
  {$EXTERNALSYM PAUTHZ_ACCESS_REPLY}
144
 
  _AUTHZ_ACCESS_REPLY = record
145
 
    //
146
 
    // The length of the array representing the object type list structure. If
147
 
    // no object type is used to represent the object, then the length must be
148
 
    // set to 1.
149
 
    //
150
 
    // Note: This parameter must be filled!
151
 
    //
152
 
    ResultListLength: DWORD;
153
 
    //
154
 
    // Array of granted access masks. This memory is allocated by the RM. Access
155
 
    // check routines just fill in the values.
156
 
    //
157
 
    GrantedAccessMask: PACCESS_MASK;
158
 
    //
159
 
    // Array of SACL evaluation results.  This memory is allocated by the RM, if SACL
160
 
    // evaluation results are desired. Access check routines just fill in the values.
161
 
    // Sacl evaluation will only be performed if auditing is requested.
162
 
    //
163
 
    SaclEvaluationResults: PDWORD;
164
 
    //
165
 
    // Array of results for each element of the array. This memory is allocated
166
 
    // by the RM. Access check routines just fill in the values.
167
 
    //
168
 
    Error: PDWORD;
169
 
  end;
170
 
  {$EXTERNALSYM _AUTHZ_ACCESS_REPLY}
171
 
  AUTHZ_ACCESS_REPLY = _AUTHZ_ACCESS_REPLY;
172
 
  {$EXTERNALSYM AUTHZ_ACCESS_REPLY}
173
 
  TAuthzAccessReply = AUTHZ_ACCESS_REPLY;
174
 
  PAuthzAccessReply = PAUTHZ_ACCESS_REPLY;
175
 
 
176
 
//
177
 
// Typedefs for callback functions to be provided by the resource manager.
178
 
//
179
 
 
180
 
//
181
 
// Callback access check function takes in
182
 
//     AuthzClientContext - a client context
183
 
//     pAce - pointer to a callback ace
184
 
//     pArgs - Optional arguments that were passed to AuthzAccessCheck thru
185
 
//             AuthzAccessRequest->OptionalArguments are passed back here.
186
 
//     pbAceApplicable - The resource manager must supply whether the ace should
187
 
//         be used in the computation of access evaluation
188
 
//
189
 
// Returns
190
 
//     TRUE if the API succeeded.
191
 
//     FALSE on any intermediate errors (like failed memory allocation)
192
 
//         In case of failure, the caller must use SetLastError(ErrorValue).
193
 
//
194
 
 
195
 
type
196
 
  PFN_AUTHZ_DYNAMIC_ACCESS_CHECK = function(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE;
197
 
    pAce: PACE_HEADER; pArgs: PVOID; var pbAceApplicable: BOOL): BOOL; stdcall;
198
 
  {$EXTERNALSYM PFN_AUTHZ_DYNAMIC_ACCESS_CHECK}
199
 
  PFnAuthzDynamicAccessCheck = PFN_AUTHZ_DYNAMIC_ACCESS_CHECK;
200
 
 
201
 
//
202
 
// Callback compute dynamic groups function takes in
203
 
//     AuthzClientContext - a client context
204
 
//     pArgs - Optional arguments that supplied to AuthzInitializeClientContext*
205
 
//         thru DynamicGroupArgs are passed back here..
206
 
//     pSidAttrArray - To allocate and return an array of (sids, attribute)
207
 
//         pairs to be added to the normal part of the client context.
208
 
//     pSidCount - Number of elements in pSidAttrArray
209
 
//     pRestrictedSidAttrArray - To allocate and return an array of (sids, attribute)
210
 
//         pairs to be added to the restricted part of the client context.
211
 
//     pRestrictedSidCount - Number of elements in pRestrictedSidAttrArray
212
 
//
213
 
// Note:
214
 
//    Memory returned thru both these array will be freed by the callback
215
 
//    free function defined by the resource manager.
216
 
//
217
 
// Returns
218
 
//     TRUE if the API succeeded.
219
 
//     FALSE on any intermediate errors (like failed memory allocation)
220
 
//         In case of failure, the caller must use SetLastError(ErrorValue).
221
 
//
222
 
 
223
 
type
224
 
  PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS = function(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE;
225
 
    Args: PVOID; var pSidAttrArray: PSID_AND_ATTRIBUTES; var pSidCount: DWORD;
226
 
    var pRestrictedSidAttrArray: PSID_AND_ATTRIBUTES; var pRestrictedSidCount: DWORD): BOOL; stdcall;
227
 
  {$EXTERNALSYM PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS}
228
 
  PFnAuthzComputeDynamicGroups = PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS;
229
 
 
230
 
//
231
 
// Callback free function takes in
232
 
//     pSidAttrArray - To be freed. This has been allocated by the compute
233
 
//     dynamic groups function.
234
 
//
235
 
 
236
 
  PFN_AUTHZ_FREE_DYNAMIC_GROUPS = procedure(pSidAttrArray: PSID_AND_ATTRIBUTES); stdcall;
237
 
  {$EXTERNALSYM PFN_AUTHZ_FREE_DYNAMIC_GROUPS}
238
 
  PFnAuthzFreeDynamicGroups = PFN_AUTHZ_FREE_DYNAMIC_GROUPS;
239
 
 
240
 
//
241
 
// Valid flags for AuthzAccessCheck
242
 
//
243
 
 
244
 
const
245
 
  AUTHZ_ACCESS_CHECK_NO_DEEP_COPY_SD = $00000001;
246
 
  {$EXTERNALSYM AUTHZ_ACCESS_CHECK_NO_DEEP_COPY_SD}
247
 
 
248
 
function AuthzAccessCheck(Flags: DWORD; hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; pRequest: PAUTHZ_ACCESS_REQUEST;
249
 
  hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; pSecurityDescriptor: PSECURITY_DESCRIPTOR; OptionalSecurityDescriptorArray: PPSECURITY_DESCRIPTOR;
250
 
  OptionalSecurityDescriptorCount: DWORD; pReply: PAUTHZ_ACCESS_REPLY; phAccessCheckResultsOPTIONAL: PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE): BOOL; stdcall;
251
 
{$EXTERNALSYM AuthzAccessCheck}
252
 
 
253
 
function AuthzCachedAccessCheck(Flags: DWORD; hAccessCheckResults: AUTHZ_ACCESS_CHECK_RESULTS_HANDLE; pRequest: PAUTHZ_ACCESS_REQUEST; hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; pReply: PAUTHZ_ACCESS_REPLY): BOOL; stdcall;
254
 
{$EXTERNALSYM AuthzCachedAccessCheck}
255
 
 
256
 
function AuthzOpenObjectAudit(Flags: DWORD; hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; pRequest: PAUTHZ_ACCESS_REQUEST; hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; pSecurityDescriptor: PSECURITY_DESCRIPTOR; OptionalSecurityDescriptorArray: PPSECURITY_DESCRIPTOR; OptionalSecurityDescriptorCount: DWORD; pReply: PAUTHZ_ACCESS_REPLY): BOOL; stdcall;
257
 
{$EXTERNALSYM AuthzOpenObjectAudit}
258
 
 
259
 
function AuthzFreeHandle(hAccessCheckResults: AUTHZ_ACCESS_CHECK_RESULTS_HANDLE): BOOL; stdcall;
260
 
{$EXTERNALSYM AuthzFreeHandle}
261
 
 
262
 
//
263
 
// Flags for AuthzInitializeResourceManager
264
 
//
265
 
 
266
 
const
267
 
  AUTHZ_RM_FLAG_NO_AUDIT = $1;
268
 
  {$EXTERNALSYM AUTHZ_RM_FLAG_NO_AUDIT}
269
 
 
270
 
  AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION = $2;
271
 
  {$EXTERNALSYM AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION}
272
 
 
273
 
  AUTHZ_VALID_RM_INIT_FLAGS = AUTHZ_RM_FLAG_NO_AUDIT or AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION;
274
 
  {$EXTERNALSYM AUTHZ_VALID_RM_INIT_FLAGS}
275
 
 
276
 
function AuthzInitializeResourceManager(Flags: DWORD; pfnDynamicAccessCheck: PFN_AUTHZ_DYNAMIC_ACCESS_CHECK; pfnComputeDynamicGroups: PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS; pfnFreeDynamicGroups: PFN_AUTHZ_FREE_DYNAMIC_GROUPS; szResourceManagerName: LPCWSTR; phAuthzResourceManager: PAUTHZ_RESOURCE_MANAGER_HANDLE): BOOL; stdcall;
277
 
{$EXTERNALSYM AuthzInitializeResourceManager}
278
 
 
279
 
function AuthzFreeResourceManager(hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE): BOOL; stdcall;
280
 
{$EXTERNALSYM AuthzFreeResourceManager}
281
 
 
282
 
function AuthzInitializeContextFromToken(Flags: DWORD; TokenHandle: HANDLE; hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE; pExpirationTime: PLARGE_INTEGER; Identifier: LUID; DynamicGroupArgs: PVOID; phAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
283
 
{$EXTERNALSYM AuthzInitializeContextFromToken}
284
 
 
285
 
function AuthzInitializeContextFromSid(Flags: DWORD; UserSid: PSID; hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE; pExpirationTime: PLARGE_INTEGER; Identifier: LUID; DynamicGroupArgs: PVOID; phAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
286
 
{$EXTERNALSYM AuthzInitializeContextFromSid}
287
 
 
288
 
function AuthzInitializeContextFromAuthzContext(Flags: DWORD; hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; pExpirationTime: PLARGE_INTEGER; Identifier: LUID; DynamicGroupArgs: PVOID; phNewAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
289
 
{$EXTERNALSYM AuthzInitializeContextFromAuthzContext}
290
 
 
291
 
function AuthzAddSidsToContext(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; Sids: PSID_AND_ATTRIBUTES; SidCount: DWORD; RestrictedSids: PSID_AND_ATTRIBUTES; RestrictedSidCount: DWORD; phNewAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
292
 
{$EXTERNALSYM AuthzAddSidsToContext}
293
 
 
294
 
//
295
 
// Enumeration type to be used to specify the type of information to be
296
 
// retrieved from an existing AuthzClientContext.
297
 
//
298
 
 
299
 
type
300
 
  _AUTHZ_CONTEXT_INFORMATION_CLASS = (
301
 
    AuthzContextInfo__0,
302
 
    AuthzContextInfoUserSid,
303
 
    AuthzContextInfoGroupsSids,
304
 
    AuthzContextInfoRestrictedSids,
305
 
    AuthzContextInfoPrivileges,
306
 
    AuthzContextInfoExpirationTime,
307
 
    AuthzContextInfoServerContext,
308
 
    AuthzContextInfoIdentifier,
309
 
    AuthzContextInfoSource,
310
 
    AuthzContextInfoAll,
311
 
    AuthzContextInfoAuthenticationId);
312
 
  {$EXTERNALSYM _AUTHZ_CONTEXT_INFORMATION_CLASS}
313
 
  AUTHZ_CONTEXT_INFORMATION_CLASS = _AUTHZ_CONTEXT_INFORMATION_CLASS;
314
 
  {$EXTERNALSYM AUTHZ_CONTEXT_INFORMATION_CLASS}
315
 
  TAuthzContextInformationClass = AUTHZ_CONTEXT_INFORMATION_CLASS;
316
 
 
317
 
function AuthzGetInformationFromContext(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE;
318
 
  InfoClass: AUTHZ_CONTEXT_INFORMATION_CLASS; BufferSize: DWORD; pSizeRequired: PDWORD;
319
 
  Buffer: PVOID): BOOL; stdcall;
320
 
{$EXTERNALSYM AuthzGetInformationFromContext}
321
 
 
322
 
function AuthzFreeContext(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
323
 
{$EXTERNALSYM AuthzFreeContext}
324
 
 
325
 
//
326
 
// Valid flags that may be used in AuthzInitializeObjectAccessAuditEvent().
327
 
//
328
 
 
329
 
const
330
 
  AUTHZ_NO_SUCCESS_AUDIT = $00000001;
331
 
  {$EXTERNALSYM AUTHZ_NO_SUCCESS_AUDIT}
332
 
  AUTHZ_NO_FAILURE_AUDIT = $00000002;
333
 
  {$EXTERNALSYM AUTHZ_NO_FAILURE_AUDIT}
334
 
  AUTHZ_NO_ALLOC_STRINGS = $00000004;
335
 
  {$EXTERNALSYM AUTHZ_NO_ALLOC_STRINGS}
336
 
 
337
 
  AUTHZ_VALID_OBJECT_ACCESS_AUDIT_FLAGS = AUTHZ_NO_SUCCESS_AUDIT or AUTHZ_NO_FAILURE_AUDIT or AUTHZ_NO_ALLOC_STRINGS;
338
 
  {$EXTERNALSYM AUTHZ_VALID_OBJECT_ACCESS_AUDIT_FLAGS}
339
 
 
340
 
function AuthzInitializeObjectAccessAuditEvent(Flags: DWORD; hAuditEventType: AUTHZ_AUDIT_EVENT_TYPE_HANDLE;
341
 
  szOperationType: PWSTR; szObjectType: PWSTR; szObjectName: PWSTR; szAdditionalInfo: PWSTR;
342
 
  phAuditEvent: PAUTHZ_AUDIT_EVENT_HANDLE; dwAdditionalParameterCount: DWORD {, ...}): BOOL; stdcall;
343
 
{$EXTERNALSYM AuthzInitializeObjectAccessAuditEvent}
344
 
 
345
 
function AuthzInitializeObjectAccessAuditEvent2(Flags: DWORD; hAuditEventType: AUTHZ_AUDIT_EVENT_TYPE_HANDLE;
346
 
  szOperationType: PWSTR; szObjectType: PWSTR; szObjectName: PWSTR; szAdditionalInfo, szAdditionalInfo2: PWSTR;
347
 
  phAuditEvent: PAUTHZ_AUDIT_EVENT_HANDLE; dwAdditionalParameterCount: DWORD {, ...}): BOOL; stdcall;
348
 
{$EXTERNALSYM AuthzInitializeObjectAccessAuditEvent2}
349
 
 
350
 
//
351
 
// Enumeration type to be used to specify the type of information to be
352
 
// retrieved from an existing AUTHZ_AUDIT_EVENT_HANDLE.
353
 
//
354
 
 
355
 
type
356
 
  _AUTHZ_AUDIT_EVENT_INFORMATION_CLASS = (
357
 
    AuthzAuditEvent__0,
358
 
    AuthzAuditEventInfoFlags,
359
 
    AuthzAuditEventInfoOperationType,
360
 
    AuthzAuditEventInfoObjectType,
361
 
    AuthzAuditEventInfoObjectName,
362
 
    AuthzAuditEventInfoAdditionalInfo);
363
 
  {$EXTERNALSYM _AUTHZ_AUDIT_EVENT_INFORMATION_CLASS}
364
 
  AUTHZ_AUDIT_EVENT_INFORMATION_CLASS = _AUTHZ_AUDIT_EVENT_INFORMATION_CLASS;
365
 
  {$EXTERNALSYM AUTHZ_AUDIT_EVENT_INFORMATION_CLASS}
366
 
  AuthzAuditEventInformationClass = AUTHZ_AUDIT_EVENT_INFORMATION_CLASS;
367
 
 
368
 
// todo this one seems not to be exported from authz.dll
369
 
 
370
 
function AuthzGetInformationFromAuditEvent(hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; InfoClass: AUTHZ_AUDIT_EVENT_INFORMATION_CLASS; BufferSize: DWORD; pSizeRequired: PDWORD; Buffer: PVOID): BOOL; stdcall;
371
 
{$EXTERNALSYM AuthzGetInformationFromAuditEvent}
372
 
 
373
 
function AuthzFreeAuditEvent(hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE): BOOL; stdcall;
374
 
{$EXTERNALSYM AuthzFreeAuditEvent}
375
 
 
376
 
(* TODO
377
 
//
378
 
// Support for generic auditing.
379
 
//
380
 
 
381
 
typedef struct _AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET
382
 
{
383
 
    PWSTR szObjectTypeName;
384
 
    DWORD dwOffset;
385
 
} AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET, *PAUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET;
386
 
 
387
 
typedef struct _AUTHZ_SOURCE_SCHEMA_REGISTRATION
388
 
{
389
 
    DWORD dwFlags;
390
 
    PWSTR szEventSourceName;
391
 
    PWSTR szEventMessageFile;
392
 
    PWSTR szEventSourceXmlSchemaFile;
393
 
    PWSTR szEventAccessStringsFile;
394
 
    PWSTR szExecutableImagePath;
395
 
    PVOID pReserved;
396
 
    DWORD dwObjectTypeNameCount;
397
 
    AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET ObjectTypeNames[ANYSIZE_ARRAY];
398
 
} AUTHZ_SOURCE_SCHEMA_REGISTRATION, *PAUTHZ_SOURCE_SCHEMA_REGISTRATION;
399
 
 
400
 
#define AUTHZ_FLAG_ALLOW_MULTIPLE_SOURCE_INSTANCES 0x1
401
 
 
402
 
AUTHZAPI
403
 
BOOL 
404
 
WINAPI
405
 
AuthzInstallSecurityEventSource(
406
 
    IN DWORD                             dwFlags,
407
 
    IN PAUTHZ_SOURCE_SCHEMA_REGISTRATION pRegistration
408
 
    );
409
 
 
410
 
AUTHZAPI
411
 
BOOL
412
 
WINAPI
413
 
AuthzUninstallSecurityEventSource(
414
 
    IN DWORD  dwFlags,
415
 
    IN PCWSTR szEventSourceName
416
 
    );
417
 
 
418
 
AUTHZAPI
419
 
BOOL
420
 
WINAPI
421
 
AuthzEnumerateSecurityEventSources(
422
 
    IN     DWORD                             dwFlags,
423
 
    OUT    PAUTHZ_SOURCE_SCHEMA_REGISTRATION Buffer,
424
 
    OUT    PDWORD                            pdwCount,
425
 
    IN OUT PDWORD                            pdwLength
426
 
    );
427
 
    
428
 
AUTHZAPI
429
 
BOOL
430
 
WINAPI
431
 
AuthzRegisterSecurityEventSource(
432
 
    IN  DWORD                                 dwFlags,
433
 
    IN  PCWSTR                                szEventSourceName,
434
 
    OUT PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE phEventProvider
435
 
    );
436
 
    
437
 
AUTHZAPI
438
 
BOOL
439
 
WINAPI
440
 
AuthzUnregisterSecurityEventSource(
441
 
    IN     DWORD                                 dwFlags,
442
 
    IN OUT PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE phEventProvider
443
 
    );
444
 
 
445
 
AUTHZAPI
446
 
BOOL
447
 
WINAPI
448
 
AuthzReportSecurityEvent(
449
 
    IN     DWORD                                dwFlags,
450
 
    IN OUT AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE hEventProvider,
451
 
    IN     DWORD                                dwAuditId,
452
 
    IN     PSID                                 pUserSid        OPTIONAL,
453
 
    IN     DWORD                                dwCount,
454
 
    ...    
455
 
    );
456
 
 
457
 
AUTHZAPI
458
 
BOOL
459
 
WINAPI
460
 
AuthzReportSecurityEventFromParams(
461
 
    IN     DWORD                                dwFlags,
462
 
    IN OUT AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE hEventProvider,
463
 
    IN     DWORD                                dwAuditId,
464
 
    IN     PSID                                 pUserSid       OPTIONAL,
465
 
    IN     PAUDIT_PARAMS                        pParams
466
 
    );
467
 
*)
468
 
 
469
 
implementation
470
 
 
471
 
const
472
 
  authzlib = 'authz.dll';
473
 
 
474
 
{$IFDEF DYNAMIC_LINK}
475
 
 
476
 
var
477
 
  _AuthzAccessCheck: Pointer;
478
 
 
479
 
function AuthzAccessCheck;
480
 
begin
481
 
  GetProcedureAddress(_AuthzAccessCheck, authzlib, 'AuthzAccessCheck');
482
 
  asm
483
 
        MOV     ESP, EBP
484
 
        POP     EBP
485
 
        JMP     [_AuthzAccessCheck]
486
 
  end;
487
 
end;
488
 
 
489
 
var
490
 
  _AuthzCachedAccessCheck: Pointer;
491
 
 
492
 
function AuthzCachedAccessCheck;
493
 
begin
494
 
  GetProcedureAddress(_AuthzCachedAccessCheck, authzlib, 'AuthzCachedAccessCheck');
495
 
  asm
496
 
        MOV     ESP, EBP
497
 
        POP     EBP
498
 
        JMP     [_AuthzCachedAccessCheck]
499
 
  end;
500
 
end;
501
 
 
502
 
var
503
 
  _AuthzOpenObjectAudit: Pointer;
504
 
 
505
 
function AuthzOpenObjectAudit;
506
 
begin
507
 
  GetProcedureAddress(_AuthzOpenObjectAudit, authzlib, 'AuthzOpenObjectAudit');
508
 
  asm
509
 
        MOV     ESP, EBP
510
 
        POP     EBP
511
 
        JMP     [_AuthzOpenObjectAudit]
512
 
  end;
513
 
end;
514
 
 
515
 
var
516
 
  _AuthzFreeHandle: Pointer;
517
 
 
518
 
function AuthzFreeHandle;
519
 
begin
520
 
  GetProcedureAddress(_AuthzFreeHandle, authzlib, 'AuthzFreeHandle');
521
 
  asm
522
 
        MOV     ESP, EBP
523
 
        POP     EBP
524
 
        JMP     [_AuthzFreeHandle]
525
 
  end;
526
 
end;
527
 
 
528
 
var
529
 
  _AuthzInitializeResourceManager: Pointer;
530
 
 
531
 
function AuthzInitializeResourceManager;
532
 
begin
533
 
  GetProcedureAddress(_AuthzInitializeResourceManager, authzlib, 'AuthzInitializeResourceManager');
534
 
  asm
535
 
        MOV     ESP, EBP
536
 
        POP     EBP
537
 
        JMP     [_AuthzInitializeResourceManager]
538
 
  end;
539
 
end;
540
 
 
541
 
var
542
 
  _AuthzFreeResourceManager: Pointer;
543
 
 
544
 
function AuthzFreeResourceManager;
545
 
begin
546
 
  GetProcedureAddress(_AuthzFreeResourceManager, authzlib, 'AuthzFreeResourceManager');
547
 
  asm
548
 
        MOV     ESP, EBP
549
 
        POP     EBP
550
 
        JMP     [_AuthzFreeResourceManager]
551
 
  end;
552
 
end;
553
 
 
554
 
var
555
 
  _AuthzInitializeContextFromToken: Pointer;
556
 
 
557
 
function AuthzInitializeContextFromToken;
558
 
begin
559
 
  GetProcedureAddress(_AuthzInitializeContextFromToken, authzlib, 'AuthzInitializeContextFromToken');
560
 
  asm
561
 
        MOV     ESP, EBP
562
 
        POP     EBP
563
 
        JMP     [_AuthzInitializeContextFromToken]
564
 
  end;
565
 
end;
566
 
 
567
 
var
568
 
  _AuthzInitializeContextFromSid: Pointer;
569
 
 
570
 
function AuthzInitializeContextFromSid;
571
 
begin
572
 
  GetProcedureAddress(_AuthzInitializeContextFromSid, authzlib, 'AuthzInitializeContextFromSid');
573
 
  asm
574
 
        MOV     ESP, EBP
575
 
        POP     EBP
576
 
        JMP     [_AuthzInitializeContextFromSid]
577
 
  end;
578
 
end;
579
 
 
580
 
var
581
 
  _AuthzInitCxtFromAuthzCxt: Pointer;
582
 
 
583
 
function AuthzInitializeContextFromAuthzContext;
584
 
begin
585
 
  GetProcedureAddress(_AuthzInitCxtFromAuthzCxt, authzlib, 'AuthzInitializeContextFromAuthzContext');
586
 
  asm
587
 
        MOV     ESP, EBP
588
 
        POP     EBP
589
 
        JMP     [_AuthzInitCxtFromAuthzCxt]
590
 
  end;
591
 
end;
592
 
 
593
 
var
594
 
  _AuthzAddSidsToContext: Pointer;
595
 
 
596
 
function AuthzAddSidsToContext;
597
 
begin
598
 
  GetProcedureAddress(_AuthzAddSidsToContext, authzlib, 'AuthzAddSidsToContext');
599
 
  asm
600
 
        MOV     ESP, EBP
601
 
        POP     EBP
602
 
        JMP     [_AuthzAddSidsToContext]
603
 
  end;
604
 
end;
605
 
 
606
 
var
607
 
  _AuthzGetInformationFromContext: Pointer;
608
 
 
609
 
function AuthzGetInformationFromContext;
610
 
begin
611
 
  GetProcedureAddress(_AuthzGetInformationFromContext, authzlib, 'AuthzGetInformationFromContext');
612
 
  asm
613
 
        MOV     ESP, EBP
614
 
        POP     EBP
615
 
        JMP     [_AuthzGetInformationFromContext]
616
 
  end;
617
 
end;
618
 
 
619
 
var
620
 
  _AuthzFreeContext: Pointer;
621
 
 
622
 
function AuthzFreeContext;
623
 
begin
624
 
  GetProcedureAddress(_AuthzFreeContext, authzlib, 'AuthzFreeContext');
625
 
  asm
626
 
        MOV     ESP, EBP
627
 
        POP     EBP
628
 
        JMP     [_AuthzFreeContext]
629
 
  end;
630
 
end;
631
 
 
632
 
var
633
 
  _AuthzInitObjAccAuditEvent: Pointer;
634
 
 
635
 
function AuthzInitializeObjectAccessAuditEvent;
636
 
begin
637
 
  GetProcedureAddress(_AuthzInitObjAccAuditEvent, authzlib, 'AuthzInitializeObjectAccessAuditEvent');
638
 
  asm
639
 
        MOV     ESP, EBP
640
 
        POP     EBP
641
 
        JMP     [_AuthzInitObjAccAuditEvent]
642
 
  end;
643
 
end;
644
 
 
645
 
var
646
 
  _AuthzInitObjAccAuditEvent2: Pointer;
647
 
 
648
 
function AuthzInitializeObjectAccessAuditEvent2;
649
 
begin
650
 
  GetProcedureAddress(_AuthzInitObjAccAuditEvent2, authzlib, 'AuthzInitializeObjectAccessAuditEvent2');
651
 
  asm
652
 
        MOV     ESP, EBP
653
 
        POP     EBP
654
 
        JMP     [_AuthzInitObjAccAuditEvent2]
655
 
  end;
656
 
end;
657
 
 
658
 
var
659
 
  _AuthzGetInfoFromAuditEvent: Pointer;
660
 
 
661
 
function AuthzGetInformationFromAuditEvent;
662
 
begin
663
 
  GetProcedureAddress(_AuthzGetInfoFromAuditEvent, authzlib, 'AuthzGetInformationFromAuditEvent');
664
 
  asm
665
 
        MOV     ESP, EBP
666
 
        POP     EBP
667
 
        JMP     [_AuthzGetInfoFromAuditEvent]
668
 
  end;
669
 
end;
670
 
 
671
 
var
672
 
  _AuthzFreeAuditEvent: Pointer;
673
 
 
674
 
function AuthzFreeAuditEvent;
675
 
begin
676
 
  GetProcedureAddress(_AuthzFreeAuditEvent, authzlib, 'AuthzFreeAuditEvent');
677
 
  asm
678
 
        MOV     ESP, EBP
679
 
        POP     EBP
680
 
        JMP     [_AuthzFreeAuditEvent]
681
 
  end;
682
 
end;
683
 
 
684
 
{$ELSE}
685
 
 
686
 
function AuthzAccessCheck; external authzlib name 'AuthzAccessCheck';
687
 
function AuthzCachedAccessCheck; external authzlib name 'AuthzCachedAccessCheck';
688
 
function AuthzOpenObjectAudit; external authzlib name 'AuthzOpenObjectAudit';
689
 
function AuthzFreeHandle; external authzlib name 'AuthzFreeHandle';
690
 
function AuthzInitializeResourceManager; external authzlib name 'AuthzInitializeResourceManager';
691
 
function AuthzFreeResourceManager; external authzlib name 'AuthzFreeResourceManager';
692
 
function AuthzInitializeContextFromToken; external authzlib name 'AuthzInitializeContextFromToken';
693
 
function AuthzInitializeContextFromSid; external authzlib name 'AuthzInitializeContextFromSid';
694
 
function AuthzInitializeContextFromAuthzContext; external authzlib name 'AuthzInitializeContextFromAuthzContext';
695
 
function AuthzAddSidsToContext; external authzlib name 'AuthzAddSidsToContext';
696
 
function AuthzGetInformationFromContext; external authzlib name 'AuthzGetInformationFromContext';
697
 
function AuthzFreeContext; external authzlib name 'AuthzFreeContext';
698
 
function AuthzInitializeObjectAccessAuditEvent; external authzlib name 'AuthzInitializeObjectAccessAuditEvent';
699
 
function AuthzInitializeObjectAccessAuditEvent2; external authzlib name 'AuthzInitializeObjectAccessAuditEvent2';
700
 
function AuthzGetInformationFromAuditEvent; external authzlib name 'AuthzGetInformationFromAuditEvent';
701
 
function AuthzFreeAuditEvent; external authzlib name 'AuthzFreeAuditEvent';
702
 
 
703
 
{$ENDIF DYNAMIC_LINK}
704
 
 
705
 
end.
 
1
{******************************************************************************}
 
2
{                                                                              }
 
3
{ Authorization Framework API interface Unit for Object Pascal                 }
 
4
{                                                                              }
 
5
{ Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
 
6
{ Corporation. All Rights Reserved.                                            }
 
7
{                                                                              }
 
8
{ The original file is: authz.h, released August 2001. The original Pascal     }
 
9
{ code is: Authz.pas, released October 2001. The initial developer of the      }
 
10
{ Pascal code is Marcel van Brakel (brakelm att chello dott nl).               }
 
11
{                                                                              }
 
12
{ Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
 
13
{ Marcel van Brakel. All Rights Reserved.                                      }
 
14
{                                                                              }
 
15
{ Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
 
16
{                                                                              }
 
17
{ You may retrieve the latest version of this file at the Project JEDI         }
 
18
{ APILIB home page, located at http://jedi-apilib.sourceforge.net              }
 
19
{                                                                              }
 
20
{ The contents of this file are used with permission, subject to the Mozilla   }
 
21
{ Public License Version 1.1 (the "License"); you may not use this file except }
 
22
{ in compliance with the License. You may obtain a copy of the License at      }
 
23
{ http://www.mozilla.org/MPL/MPL-1.1.html                                      }
 
24
{                                                                              }
 
25
{ Software distributed under the License is distributed on an "AS IS" basis,   }
 
26
{ WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
 
27
{ the specific language governing rights and limitations under the License.    }
 
28
{                                                                              }
 
29
{ Alternatively, the contents of this file may be used under the terms of the  }
 
30
{ GNU Lesser General Public License (the  "LGPL License"), in which case the   }
 
31
{ provisions of the LGPL License are applicable instead of those above.        }
 
32
{ If you wish to allow use of your version of this file only under the terms   }
 
33
{ of the LGPL License and not to allow others to use your version of this file }
 
34
{ under the MPL, indicate your decision by deleting  the provisions above and  }
 
35
{ replace  them with the notice and other provisions required by the LGPL      }
 
36
{ License.  If you do not delete the provisions above, a recipient may use     }
 
37
{ your version of this file under either the MPL or the LGPL License.          }
 
38
{                                                                              }
 
39
{ For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
 
40
{                                                                              }
 
41
{******************************************************************************}
 
42
 
 
43
 
 
44
unit JwaAuthz;
 
45
 
 
46
{$WEAKPACKAGEUNIT}
 
47
 
 
48
{$HPPEMIT ''}
 
49
{$HPPEMIT '#include "authz.h"'}
 
50
{$HPPEMIT ''}
 
51
 
 
52
{$I jediapilib.inc}
 
53
 
 
54
interface
 
55
 
 
56
uses
 
57
  JwaWinNT, JwaWinType;
 
58
 
 
59
//
 
60
// Flags which may be used at the time of client context creation using a sid.
 
61
//
 
62
 
 
63
const
 
64
  AUTHZ_SKIP_TOKEN_GROUPS = $2;
 
65
  {$EXTERNALSYM AUTHZ_SKIP_TOKEN_GROUPS}
 
66
  AUTHZ_REQUIRE_S4U_LOGON = $4;
 
67
  {$EXTERNALSYM AUTHZ_REQUIRE_S4U_LOGON}
 
68
 
 
69
type
 
70
  AUTHZ_ACCESS_CHECK_RESULTS_HANDLE = HANDLE;
 
71
  {$EXTERNALSYM AUTHZ_ACCESS_CHECK_RESULTS_HANDLE}
 
72
  AUTHZ_CLIENT_CONTEXT_HANDLE = HANDLE;
 
73
  {$EXTERNALSYM AUTHZ_CLIENT_CONTEXT_HANDLE}
 
74
  AUTHZ_RESOURCE_MANAGER_HANDLE = HANDLE;
 
75
  {$EXTERNALSYM AUTHZ_RESOURCE_MANAGER_HANDLE}
 
76
  AUTHZ_AUDIT_EVENT_HANDLE = HANDLE;
 
77
  {$EXTERNALSYM AUTHZ_AUDIT_EVENT_HANDLE}
 
78
  AUTHZ_AUDIT_EVENT_TYPE_HANDLE = HANDLE;
 
79
  {$EXTERNALSYM AUTHZ_AUDIT_EVENT_TYPE_HANDLE}
 
80
  AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE = HANDLE;
 
81
  {$EXTERNALSYM AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE}
 
82
 
 
83
  PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE = ^AUTHZ_ACCESS_CHECK_RESULTS_HANDLE;
 
84
  {$EXTERNALSYM PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE}
 
85
  PAUTHZ_CLIENT_CONTEXT_HANDLE = ^AUTHZ_CLIENT_CONTEXT_HANDLE;
 
86
  {$EXTERNALSYM PAUTHZ_CLIENT_CONTEXT_HANDLE}
 
87
  PAUTHZ_RESOURCE_MANAGER_HANDLE = ^AUTHZ_RESOURCE_MANAGER_HANDLE;
 
88
  {$EXTERNALSYM PAUTHZ_RESOURCE_MANAGER_HANDLE}
 
89
  PAUTHZ_AUDIT_EVENT_HANDLE = ^AUTHZ_AUDIT_EVENT_HANDLE;
 
90
  {$EXTERNALSYM PAUTHZ_AUDIT_EVENT_HANDLE}
 
91
  PAUTHZ_AUDIT_EVENT_TYPE_HANDLE = ^AUTHZ_AUDIT_EVENT_TYPE_HANDLE;
 
92
  {$EXTERNALSYM PAUTHZ_AUDIT_EVENT_TYPE_HANDLE}
 
93
  PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE = ^AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE;
 
94
  {$EXTERNALSYM PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE}
 
95
 
 
96
//
 
97
// Structure defining the access check request.
 
98
//
 
99
 
 
100
  PAUTHZ_ACCESS_REQUEST = ^AUTHZ_ACCESS_REQUEST;
 
101
  {$EXTERNALSYM PAUTHZ_ACCESS_REQUEST}
 
102
  _AUTHZ_ACCESS_REQUEST = record
 
103
    DesiredAccess: ACCESS_MASK;
 
104
    //
 
105
    // To replace the principal self sid in the acl.
 
106
    //
 
107
    PrincipalSelfSid: PSID;
 
108
    //
 
109
    // Object type list represented by an array of (level, guid) pair and the
 
110
    // number of elements in the array. This is a post-fix representation of the
 
111
    // object tree.
 
112
    // These fields should be set to NULL and 0 respectively except when per
 
113
    // property access is desired.
 
114
    //
 
115
    ObjectTypeList: POBJECT_TYPE_LIST;
 
116
    ObjectTypeListLength: DWORD;
 
117
    //
 
118
    // To support completely business rules based access. This will be passed as
 
119
    // input to the callback access check function. Access check algorithm does
 
120
    // not interpret these.
 
121
    //
 
122
    OptionalArguments: PVOID;
 
123
  end;
 
124
  {$EXTERNALSYM _AUTHZ_ACCESS_REQUEST}
 
125
  AUTHZ_ACCESS_REQUEST = _AUTHZ_ACCESS_REQUEST;
 
126
  {$EXTERNALSYM AUTHZ_ACCESS_REQUEST}
 
127
  TAuthzAccessRequest = AUTHZ_ACCESS_REQUEST;
 
128
  PAuthzAccessRequest = PAUTHZ_ACCESS_REQUEST;
 
129
 
 
130
//
 
131
// Structure to return the results of the access check call.
 
132
//
 
133
 
 
134
const
 
135
  AUTHZ_GENERATE_SUCCESS_AUDIT = $1;
 
136
  {$EXTERNALSYM AUTHZ_GENERATE_SUCCESS_AUDIT}
 
137
  AUTHZ_GENERATE_FAILURE_AUDIT = $2;
 
138
  {$EXTERNALSYM AUTHZ_GENERATE_FAILURE_AUDIT}
 
139
 
 
140
type
 
141
  PAUTHZ_ACCESS_REPLY = ^AUTHZ_ACCESS_REPLY;
 
142
  {$EXTERNALSYM PAUTHZ_ACCESS_REPLY}
 
143
  _AUTHZ_ACCESS_REPLY = record
 
144
    //
 
145
    // The length of the array representing the object type list structure. If
 
146
    // no object type is used to represent the object, then the length must be
 
147
    // set to 1.
 
148
    //
 
149
    // Note: This parameter must be filled!
 
150
    //
 
151
    ResultListLength: DWORD;
 
152
    //
 
153
    // Array of granted access masks. This memory is allocated by the RM. Access
 
154
    // check routines just fill in the values.
 
155
    //
 
156
    GrantedAccessMask: PACCESS_MASK;
 
157
    //
 
158
    // Array of SACL evaluation results.  This memory is allocated by the RM, if SACL
 
159
    // evaluation results are desired. Access check routines just fill in the values.
 
160
    // Sacl evaluation will only be performed if auditing is requested.
 
161
    //
 
162
    SaclEvaluationResults: PDWORD;
 
163
    //
 
164
    // Array of results for each element of the array. This memory is allocated
 
165
    // by the RM. Access check routines just fill in the values.
 
166
    //
 
167
    Error: PDWORD;
 
168
  end;
 
169
  {$EXTERNALSYM _AUTHZ_ACCESS_REPLY}
 
170
  AUTHZ_ACCESS_REPLY = _AUTHZ_ACCESS_REPLY;
 
171
  {$EXTERNALSYM AUTHZ_ACCESS_REPLY}
 
172
  TAuthzAccessReply = AUTHZ_ACCESS_REPLY;
 
173
  PAuthzAccessReply = PAUTHZ_ACCESS_REPLY;
 
174
 
 
175
//
 
176
// Typedefs for callback functions to be provided by the resource manager.
 
177
//
 
178
 
 
179
//
 
180
// Callback access check function takes in
 
181
//     AuthzClientContext - a client context
 
182
//     pAce - pointer to a callback ace
 
183
//     pArgs - Optional arguments that were passed to AuthzAccessCheck thru
 
184
//             AuthzAccessRequest->OptionalArguments are passed back here.
 
185
//     pbAceApplicable - The resource manager must supply whether the ace should
 
186
//         be used in the computation of access evaluation
 
187
//
 
188
// Returns
 
189
//     TRUE if the API succeeded.
 
190
//     FALSE on any intermediate errors (like failed memory allocation)
 
191
//         In case of failure, the caller must use SetLastError(ErrorValue).
 
192
//
 
193
 
 
194
type
 
195
  PFN_AUTHZ_DYNAMIC_ACCESS_CHECK = function(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE;
 
196
    pAce: PACE_HEADER; pArgs: PVOID; var pbAceApplicable: BOOL): BOOL; stdcall;
 
197
  {$EXTERNALSYM PFN_AUTHZ_DYNAMIC_ACCESS_CHECK}
 
198
  PFnAuthzDynamicAccessCheck = PFN_AUTHZ_DYNAMIC_ACCESS_CHECK;
 
199
 
 
200
//
 
201
// Callback compute dynamic groups function takes in
 
202
//     AuthzClientContext - a client context
 
203
//     pArgs - Optional arguments that supplied to AuthzInitializeClientContext*
 
204
//         thru DynamicGroupArgs are passed back here..
 
205
//     pSidAttrArray - To allocate and return an array of (sids, attribute)
 
206
//         pairs to be added to the normal part of the client context.
 
207
//     pSidCount - Number of elements in pSidAttrArray
 
208
//     pRestrictedSidAttrArray - To allocate and return an array of (sids, attribute)
 
209
//         pairs to be added to the restricted part of the client context.
 
210
//     pRestrictedSidCount - Number of elements in pRestrictedSidAttrArray
 
211
//
 
212
// Note:
 
213
//    Memory returned thru both these array will be freed by the callback
 
214
//    free function defined by the resource manager.
 
215
//
 
216
// Returns
 
217
//     TRUE if the API succeeded.
 
218
//     FALSE on any intermediate errors (like failed memory allocation)
 
219
//         In case of failure, the caller must use SetLastError(ErrorValue).
 
220
//
 
221
 
 
222
type
 
223
  PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS = function(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE;
 
224
    Args: PVOID; var pSidAttrArray: PSID_AND_ATTRIBUTES; var pSidCount: DWORD;
 
225
    var pRestrictedSidAttrArray: PSID_AND_ATTRIBUTES; var pRestrictedSidCount: DWORD): BOOL; stdcall;
 
226
  {$EXTERNALSYM PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS}
 
227
  PFnAuthzComputeDynamicGroups = PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS;
 
228
 
 
229
//
 
230
// Callback free function takes in
 
231
//     pSidAttrArray - To be freed. This has been allocated by the compute
 
232
//     dynamic groups function.
 
233
//
 
234
 
 
235
  PFN_AUTHZ_FREE_DYNAMIC_GROUPS = procedure(pSidAttrArray: PSID_AND_ATTRIBUTES); stdcall;
 
236
  {$EXTERNALSYM PFN_AUTHZ_FREE_DYNAMIC_GROUPS}
 
237
  PFnAuthzFreeDynamicGroups = PFN_AUTHZ_FREE_DYNAMIC_GROUPS;
 
238
 
 
239
//
 
240
// Valid flags for AuthzAccessCheck
 
241
//
 
242
 
 
243
const
 
244
  AUTHZ_ACCESS_CHECK_NO_DEEP_COPY_SD = $00000001;
 
245
  {$EXTERNALSYM AUTHZ_ACCESS_CHECK_NO_DEEP_COPY_SD}
 
246
 
 
247
function AuthzAccessCheck(Flags: DWORD; hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; pRequest: PAUTHZ_ACCESS_REQUEST;
 
248
  hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; pSecurityDescriptor: PSECURITY_DESCRIPTOR; OptionalSecurityDescriptorArray: PPSECURITY_DESCRIPTOR;
 
249
  OptionalSecurityDescriptorCount: DWORD; pReply: PAUTHZ_ACCESS_REPLY; phAccessCheckResultsOPTIONAL: PAUTHZ_ACCESS_CHECK_RESULTS_HANDLE): BOOL; stdcall;
 
250
{$EXTERNALSYM AuthzAccessCheck}
 
251
 
 
252
function AuthzCachedAccessCheck(Flags: DWORD; hAccessCheckResults: AUTHZ_ACCESS_CHECK_RESULTS_HANDLE; pRequest: PAUTHZ_ACCESS_REQUEST; hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; pReply: PAUTHZ_ACCESS_REPLY): BOOL; stdcall;
 
253
{$EXTERNALSYM AuthzCachedAccessCheck}
 
254
 
 
255
function AuthzOpenObjectAudit(Flags: DWORD; hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; pRequest: PAUTHZ_ACCESS_REQUEST; hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; pSecurityDescriptor: PSECURITY_DESCRIPTOR; OptionalSecurityDescriptorArray: PPSECURITY_DESCRIPTOR; OptionalSecurityDescriptorCount: DWORD; pReply: PAUTHZ_ACCESS_REPLY): BOOL; stdcall;
 
256
{$EXTERNALSYM AuthzOpenObjectAudit}
 
257
 
 
258
function AuthzFreeHandle(hAccessCheckResults: AUTHZ_ACCESS_CHECK_RESULTS_HANDLE): BOOL; stdcall;
 
259
{$EXTERNALSYM AuthzFreeHandle}
 
260
 
 
261
//
 
262
// Flags for AuthzInitializeResourceManager
 
263
//
 
264
 
 
265
const
 
266
  AUTHZ_RM_FLAG_NO_AUDIT = $1;
 
267
  {$EXTERNALSYM AUTHZ_RM_FLAG_NO_AUDIT}
 
268
 
 
269
  AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION = $2;
 
270
  {$EXTERNALSYM AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION}
 
271
 
 
272
  AUTHZ_VALID_RM_INIT_FLAGS = AUTHZ_RM_FLAG_NO_AUDIT or AUTHZ_RM_FLAG_INITIALIZE_UNDER_IMPERSONATION;
 
273
  {$EXTERNALSYM AUTHZ_VALID_RM_INIT_FLAGS}
 
274
 
 
275
function AuthzInitializeResourceManager(Flags: DWORD; pfnDynamicAccessCheck: PFN_AUTHZ_DYNAMIC_ACCESS_CHECK; pfnComputeDynamicGroups: PFN_AUTHZ_COMPUTE_DYNAMIC_GROUPS; pfnFreeDynamicGroups: PFN_AUTHZ_FREE_DYNAMIC_GROUPS; szResourceManagerName: LPCWSTR; phAuthzResourceManager: PAUTHZ_RESOURCE_MANAGER_HANDLE): BOOL; stdcall;
 
276
{$EXTERNALSYM AuthzInitializeResourceManager}
 
277
 
 
278
function AuthzFreeResourceManager(hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE): BOOL; stdcall;
 
279
{$EXTERNALSYM AuthzFreeResourceManager}
 
280
 
 
281
function AuthzInitializeContextFromToken(Flags: DWORD; TokenHandle: HANDLE; hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE; pExpirationTime: PLARGE_INTEGER; Identifier: LUID; DynamicGroupArgs: PVOID; phAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
 
282
{$EXTERNALSYM AuthzInitializeContextFromToken}
 
283
 
 
284
function AuthzInitializeContextFromSid(Flags: DWORD; UserSid: PSID; hAuthzResourceManager: AUTHZ_RESOURCE_MANAGER_HANDLE; pExpirationTime: PLARGE_INTEGER; Identifier: LUID; DynamicGroupArgs: PVOID; phAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
 
285
{$EXTERNALSYM AuthzInitializeContextFromSid}
 
286
 
 
287
function AuthzInitializeContextFromAuthzContext(Flags: DWORD; hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; pExpirationTime: PLARGE_INTEGER; Identifier: LUID; DynamicGroupArgs: PVOID; phNewAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
 
288
{$EXTERNALSYM AuthzInitializeContextFromAuthzContext}
 
289
 
 
290
function AuthzAddSidsToContext(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE; Sids: PSID_AND_ATTRIBUTES; SidCount: DWORD; RestrictedSids: PSID_AND_ATTRIBUTES; RestrictedSidCount: DWORD; phNewAuthzClientContext: PAUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
 
291
{$EXTERNALSYM AuthzAddSidsToContext}
 
292
 
 
293
//
 
294
// Enumeration type to be used to specify the type of information to be
 
295
// retrieved from an existing AuthzClientContext.
 
296
//
 
297
 
 
298
type
 
299
  _AUTHZ_CONTEXT_INFORMATION_CLASS = (
 
300
    AuthzContextInfo__0,
 
301
    AuthzContextInfoUserSid,
 
302
    AuthzContextInfoGroupsSids,
 
303
    AuthzContextInfoRestrictedSids,
 
304
    AuthzContextInfoPrivileges,
 
305
    AuthzContextInfoExpirationTime,
 
306
    AuthzContextInfoServerContext,
 
307
    AuthzContextInfoIdentifier,
 
308
    AuthzContextInfoSource,
 
309
    AuthzContextInfoAll,
 
310
    AuthzContextInfoAuthenticationId);
 
311
  {$EXTERNALSYM _AUTHZ_CONTEXT_INFORMATION_CLASS}
 
312
  AUTHZ_CONTEXT_INFORMATION_CLASS = _AUTHZ_CONTEXT_INFORMATION_CLASS;
 
313
  {$EXTERNALSYM AUTHZ_CONTEXT_INFORMATION_CLASS}
 
314
  TAuthzContextInformationClass = AUTHZ_CONTEXT_INFORMATION_CLASS;
 
315
 
 
316
function AuthzGetInformationFromContext(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE;
 
317
  InfoClass: AUTHZ_CONTEXT_INFORMATION_CLASS; BufferSize: DWORD; pSizeRequired: PDWORD;
 
318
  Buffer: PVOID): BOOL; stdcall;
 
319
{$EXTERNALSYM AuthzGetInformationFromContext}
 
320
 
 
321
function AuthzFreeContext(hAuthzClientContext: AUTHZ_CLIENT_CONTEXT_HANDLE): BOOL; stdcall;
 
322
{$EXTERNALSYM AuthzFreeContext}
 
323
 
 
324
//
 
325
// Valid flags that may be used in AuthzInitializeObjectAccessAuditEvent().
 
326
//
 
327
 
 
328
const
 
329
  AUTHZ_NO_SUCCESS_AUDIT = $00000001;
 
330
  {$EXTERNALSYM AUTHZ_NO_SUCCESS_AUDIT}
 
331
  AUTHZ_NO_FAILURE_AUDIT = $00000002;
 
332
  {$EXTERNALSYM AUTHZ_NO_FAILURE_AUDIT}
 
333
  AUTHZ_NO_ALLOC_STRINGS = $00000004;
 
334
  {$EXTERNALSYM AUTHZ_NO_ALLOC_STRINGS}
 
335
 
 
336
  AUTHZ_VALID_OBJECT_ACCESS_AUDIT_FLAGS = AUTHZ_NO_SUCCESS_AUDIT or AUTHZ_NO_FAILURE_AUDIT or AUTHZ_NO_ALLOC_STRINGS;
 
337
  {$EXTERNALSYM AUTHZ_VALID_OBJECT_ACCESS_AUDIT_FLAGS}
 
338
 
 
339
function AuthzInitializeObjectAccessAuditEvent(Flags: DWORD; hAuditEventType: AUTHZ_AUDIT_EVENT_TYPE_HANDLE;
 
340
  szOperationType: PWSTR; szObjectType: PWSTR; szObjectName: PWSTR; szAdditionalInfo: PWSTR;
 
341
  phAuditEvent: PAUTHZ_AUDIT_EVENT_HANDLE; dwAdditionalParameterCount: DWORD {, ...}): BOOL; stdcall;
 
342
{$EXTERNALSYM AuthzInitializeObjectAccessAuditEvent}
 
343
 
 
344
function AuthzInitializeObjectAccessAuditEvent2(Flags: DWORD; hAuditEventType: AUTHZ_AUDIT_EVENT_TYPE_HANDLE;
 
345
  szOperationType: PWSTR; szObjectType: PWSTR; szObjectName: PWSTR; szAdditionalInfo, szAdditionalInfo2: PWSTR;
 
346
  phAuditEvent: PAUTHZ_AUDIT_EVENT_HANDLE; dwAdditionalParameterCount: DWORD {, ...}): BOOL; stdcall;
 
347
{$EXTERNALSYM AuthzInitializeObjectAccessAuditEvent2}
 
348
 
 
349
//
 
350
// Enumeration type to be used to specify the type of information to be
 
351
// retrieved from an existing AUTHZ_AUDIT_EVENT_HANDLE.
 
352
//
 
353
 
 
354
type
 
355
  _AUTHZ_AUDIT_EVENT_INFORMATION_CLASS = (
 
356
    AuthzAuditEvent__0,
 
357
    AuthzAuditEventInfoFlags,
 
358
    AuthzAuditEventInfoOperationType,
 
359
    AuthzAuditEventInfoObjectType,
 
360
    AuthzAuditEventInfoObjectName,
 
361
    AuthzAuditEventInfoAdditionalInfo);
 
362
  {$EXTERNALSYM _AUTHZ_AUDIT_EVENT_INFORMATION_CLASS}
 
363
  AUTHZ_AUDIT_EVENT_INFORMATION_CLASS = _AUTHZ_AUDIT_EVENT_INFORMATION_CLASS;
 
364
  {$EXTERNALSYM AUTHZ_AUDIT_EVENT_INFORMATION_CLASS}
 
365
  AuthzAuditEventInformationClass = AUTHZ_AUDIT_EVENT_INFORMATION_CLASS;
 
366
 
 
367
// todo this one seems not to be exported from authz.dll
 
368
 
 
369
function AuthzGetInformationFromAuditEvent(hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE; InfoClass: AUTHZ_AUDIT_EVENT_INFORMATION_CLASS; BufferSize: DWORD; pSizeRequired: PDWORD; Buffer: PVOID): BOOL; stdcall;
 
370
{$EXTERNALSYM AuthzGetInformationFromAuditEvent}
 
371
 
 
372
function AuthzFreeAuditEvent(hAuditEvent: AUTHZ_AUDIT_EVENT_HANDLE): BOOL; stdcall;
 
373
{$EXTERNALSYM AuthzFreeAuditEvent}
 
374
 
 
375
(* TODO
 
376
//
 
377
// Support for generic auditing.
 
378
//
 
379
 
 
380
typedef struct _AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET
 
381
{
 
382
    PWSTR szObjectTypeName;
 
383
    DWORD dwOffset;
 
384
} AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET, *PAUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET;
 
385
 
 
386
typedef struct _AUTHZ_SOURCE_SCHEMA_REGISTRATION
 
387
{
 
388
    DWORD dwFlags;
 
389
    PWSTR szEventSourceName;
 
390
    PWSTR szEventMessageFile;
 
391
    PWSTR szEventSourceXmlSchemaFile;
 
392
    PWSTR szEventAccessStringsFile;
 
393
    PWSTR szExecutableImagePath;
 
394
    PVOID pReserved;
 
395
    DWORD dwObjectTypeNameCount;
 
396
    AUTHZ_REGISTRATION_OBJECT_TYPE_NAME_OFFSET ObjectTypeNames[ANYSIZE_ARRAY];
 
397
} AUTHZ_SOURCE_SCHEMA_REGISTRATION, *PAUTHZ_SOURCE_SCHEMA_REGISTRATION;
 
398
 
 
399
#define AUTHZ_FLAG_ALLOW_MULTIPLE_SOURCE_INSTANCES 0x1
 
400
 
 
401
AUTHZAPI
 
402
BOOL 
 
403
WINAPI
 
404
AuthzInstallSecurityEventSource(
 
405
    IN DWORD                             dwFlags,
 
406
    IN PAUTHZ_SOURCE_SCHEMA_REGISTRATION pRegistration
 
407
    );
 
408
 
 
409
AUTHZAPI
 
410
BOOL
 
411
WINAPI
 
412
AuthzUninstallSecurityEventSource(
 
413
    IN DWORD  dwFlags,
 
414
    IN PCWSTR szEventSourceName
 
415
    );
 
416
 
 
417
AUTHZAPI
 
418
BOOL
 
419
WINAPI
 
420
AuthzEnumerateSecurityEventSources(
 
421
    IN     DWORD                             dwFlags,
 
422
    OUT    PAUTHZ_SOURCE_SCHEMA_REGISTRATION Buffer,
 
423
    OUT    PDWORD                            pdwCount,
 
424
    IN OUT PDWORD                            pdwLength
 
425
    );
 
426
    
 
427
AUTHZAPI
 
428
BOOL
 
429
WINAPI
 
430
AuthzRegisterSecurityEventSource(
 
431
    IN  DWORD                                 dwFlags,
 
432
    IN  PCWSTR                                szEventSourceName,
 
433
    OUT PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE phEventProvider
 
434
    );
 
435
    
 
436
AUTHZAPI
 
437
BOOL
 
438
WINAPI
 
439
AuthzUnregisterSecurityEventSource(
 
440
    IN     DWORD                                 dwFlags,
 
441
    IN OUT PAUTHZ_SECURITY_EVENT_PROVIDER_HANDLE phEventProvider
 
442
    );
 
443
 
 
444
AUTHZAPI
 
445
BOOL
 
446
WINAPI
 
447
AuthzReportSecurityEvent(
 
448
    IN     DWORD                                dwFlags,
 
449
    IN OUT AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE hEventProvider,
 
450
    IN     DWORD                                dwAuditId,
 
451
    IN     PSID                                 pUserSid        OPTIONAL,
 
452
    IN     DWORD                                dwCount,
 
453
    ...    
 
454
    );
 
455
 
 
456
AUTHZAPI
 
457
BOOL
 
458
WINAPI
 
459
AuthzReportSecurityEventFromParams(
 
460
    IN     DWORD                                dwFlags,
 
461
    IN OUT AUTHZ_SECURITY_EVENT_PROVIDER_HANDLE hEventProvider,
 
462
    IN     DWORD                                dwAuditId,
 
463
    IN     PSID                                 pUserSid       OPTIONAL,
 
464
    IN     PAUDIT_PARAMS                        pParams
 
465
    );
 
466
*)
 
467
 
 
468
implementation
 
469
 
 
470
const
 
471
  authzlib = 'authz.dll';
 
472
 
 
473
{$IFDEF DYNAMIC_LINK}
 
474
 
 
475
var
 
476
  _AuthzAccessCheck: Pointer;
 
477
 
 
478
function AuthzAccessCheck;
 
479
begin
 
480
  GetProcedureAddress(_AuthzAccessCheck, authzlib, 'AuthzAccessCheck');
 
481
  asm
 
482
        MOV     ESP, EBP
 
483
        POP     EBP
 
484
        JMP     [_AuthzAccessCheck]
 
485
  end;
 
486
end;
 
487
 
 
488
var
 
489
  _AuthzCachedAccessCheck: Pointer;
 
490
 
 
491
function AuthzCachedAccessCheck;
 
492
begin
 
493
  GetProcedureAddress(_AuthzCachedAccessCheck, authzlib, 'AuthzCachedAccessCheck');
 
494
  asm
 
495
        MOV     ESP, EBP
 
496
        POP     EBP
 
497
        JMP     [_AuthzCachedAccessCheck]
 
498
  end;
 
499
end;
 
500
 
 
501
var
 
502
  _AuthzOpenObjectAudit: Pointer;
 
503
 
 
504
function AuthzOpenObjectAudit;
 
505
begin
 
506
  GetProcedureAddress(_AuthzOpenObjectAudit, authzlib, 'AuthzOpenObjectAudit');
 
507
  asm
 
508
        MOV     ESP, EBP
 
509
        POP     EBP
 
510
        JMP     [_AuthzOpenObjectAudit]
 
511
  end;
 
512
end;
 
513
 
 
514
var
 
515
  _AuthzFreeHandle: Pointer;
 
516
 
 
517
function AuthzFreeHandle;
 
518
begin
 
519
  GetProcedureAddress(_AuthzFreeHandle, authzlib, 'AuthzFreeHandle');
 
520
  asm
 
521
        MOV     ESP, EBP
 
522
        POP     EBP
 
523
        JMP     [_AuthzFreeHandle]
 
524
  end;
 
525
end;
 
526
 
 
527
var
 
528
  _AuthzInitializeResourceManager: Pointer;
 
529
 
 
530
function AuthzInitializeResourceManager;
 
531
begin
 
532
  GetProcedureAddress(_AuthzInitializeResourceManager, authzlib, 'AuthzInitializeResourceManager');
 
533
  asm
 
534
        MOV     ESP, EBP
 
535
        POP     EBP
 
536
        JMP     [_AuthzInitializeResourceManager]
 
537
  end;
 
538
end;
 
539
 
 
540
var
 
541
  _AuthzFreeResourceManager: Pointer;
 
542
 
 
543
function AuthzFreeResourceManager;
 
544
begin
 
545
  GetProcedureAddress(_AuthzFreeResourceManager, authzlib, 'AuthzFreeResourceManager');
 
546
  asm
 
547
        MOV     ESP, EBP
 
548
        POP     EBP
 
549
        JMP     [_AuthzFreeResourceManager]
 
550
  end;
 
551
end;
 
552
 
 
553
var
 
554
  _AuthzInitializeContextFromToken: Pointer;
 
555
 
 
556
function AuthzInitializeContextFromToken;
 
557
begin
 
558
  GetProcedureAddress(_AuthzInitializeContextFromToken, authzlib, 'AuthzInitializeContextFromToken');
 
559
  asm
 
560
        MOV     ESP, EBP
 
561
        POP     EBP
 
562
        JMP     [_AuthzInitializeContextFromToken]
 
563
  end;
 
564
end;
 
565
 
 
566
var
 
567
  _AuthzInitializeContextFromSid: Pointer;
 
568
 
 
569
function AuthzInitializeContextFromSid;
 
570
begin
 
571
  GetProcedureAddress(_AuthzInitializeContextFromSid, authzlib, 'AuthzInitializeContextFromSid');
 
572
  asm
 
573
        MOV     ESP, EBP
 
574
        POP     EBP
 
575
        JMP     [_AuthzInitializeContextFromSid]
 
576
  end;
 
577
end;
 
578
 
 
579
var
 
580
  _AuthzInitCxtFromAuthzCxt: Pointer;
 
581
 
 
582
function AuthzInitializeContextFromAuthzContext;
 
583
begin
 
584
  GetProcedureAddress(_AuthzInitCxtFromAuthzCxt, authzlib, 'AuthzInitializeContextFromAuthzContext');
 
585
  asm
 
586
        MOV     ESP, EBP
 
587
        POP     EBP
 
588
        JMP     [_AuthzInitCxtFromAuthzCxt]
 
589
  end;
 
590
end;
 
591
 
 
592
var
 
593
  _AuthzAddSidsToContext: Pointer;
 
594
 
 
595
function AuthzAddSidsToContext;
 
596
begin
 
597
  GetProcedureAddress(_AuthzAddSidsToContext, authzlib, 'AuthzAddSidsToContext');
 
598
  asm
 
599
        MOV     ESP, EBP
 
600
        POP     EBP
 
601
        JMP     [_AuthzAddSidsToContext]
 
602
  end;
 
603
end;
 
604
 
 
605
var
 
606
  _AuthzGetInformationFromContext: Pointer;
 
607
 
 
608
function AuthzGetInformationFromContext;
 
609
begin
 
610
  GetProcedureAddress(_AuthzGetInformationFromContext, authzlib, 'AuthzGetInformationFromContext');
 
611
  asm
 
612
        MOV     ESP, EBP
 
613
        POP     EBP
 
614
        JMP     [_AuthzGetInformationFromContext]
 
615
  end;
 
616
end;
 
617
 
 
618
var
 
619
  _AuthzFreeContext: Pointer;
 
620
 
 
621
function AuthzFreeContext;
 
622
begin
 
623
  GetProcedureAddress(_AuthzFreeContext, authzlib, 'AuthzFreeContext');
 
624
  asm
 
625
        MOV     ESP, EBP
 
626
        POP     EBP
 
627
        JMP     [_AuthzFreeContext]
 
628
  end;
 
629
end;
 
630
 
 
631
var
 
632
  _AuthzInitObjAccAuditEvent: Pointer;
 
633
 
 
634
function AuthzInitializeObjectAccessAuditEvent;
 
635
begin
 
636
  GetProcedureAddress(_AuthzInitObjAccAuditEvent, authzlib, 'AuthzInitializeObjectAccessAuditEvent');
 
637
  asm
 
638
        MOV     ESP, EBP
 
639
        POP     EBP
 
640
        JMP     [_AuthzInitObjAccAuditEvent]
 
641
  end;
 
642
end;
 
643
 
 
644
var
 
645
  _AuthzInitObjAccAuditEvent2: Pointer;
 
646
 
 
647
function AuthzInitializeObjectAccessAuditEvent2;
 
648
begin
 
649
  GetProcedureAddress(_AuthzInitObjAccAuditEvent2, authzlib, 'AuthzInitializeObjectAccessAuditEvent2');
 
650
  asm
 
651
        MOV     ESP, EBP
 
652
        POP     EBP
 
653
        JMP     [_AuthzInitObjAccAuditEvent2]
 
654
  end;
 
655
end;
 
656
 
 
657
var
 
658
  _AuthzGetInfoFromAuditEvent: Pointer;
 
659
 
 
660
function AuthzGetInformationFromAuditEvent;
 
661
begin
 
662
  GetProcedureAddress(_AuthzGetInfoFromAuditEvent, authzlib, 'AuthzGetInformationFromAuditEvent');
 
663
  asm
 
664
        MOV     ESP, EBP
 
665
        POP     EBP
 
666
        JMP     [_AuthzGetInfoFromAuditEvent]
 
667
  end;
 
668
end;
 
669
 
 
670
var
 
671
  _AuthzFreeAuditEvent: Pointer;
 
672
 
 
673
function AuthzFreeAuditEvent;
 
674
begin
 
675
  GetProcedureAddress(_AuthzFreeAuditEvent, authzlib, 'AuthzFreeAuditEvent');
 
676
  asm
 
677
        MOV     ESP, EBP
 
678
        POP     EBP
 
679
        JMP     [_AuthzFreeAuditEvent]
 
680
  end;
 
681
end;
 
682
 
 
683
{$ELSE}
 
684
 
 
685
function AuthzAccessCheck; external authzlib name 'AuthzAccessCheck';
 
686
function AuthzCachedAccessCheck; external authzlib name 'AuthzCachedAccessCheck';
 
687
function AuthzOpenObjectAudit; external authzlib name 'AuthzOpenObjectAudit';
 
688
function AuthzFreeHandle; external authzlib name 'AuthzFreeHandle';
 
689
function AuthzInitializeResourceManager; external authzlib name 'AuthzInitializeResourceManager';
 
690
function AuthzFreeResourceManager; external authzlib name 'AuthzFreeResourceManager';
 
691
function AuthzInitializeContextFromToken; external authzlib name 'AuthzInitializeContextFromToken';
 
692
function AuthzInitializeContextFromSid; external authzlib name 'AuthzInitializeContextFromSid';
 
693
function AuthzInitializeContextFromAuthzContext; external authzlib name 'AuthzInitializeContextFromAuthzContext';
 
694
function AuthzAddSidsToContext; external authzlib name 'AuthzAddSidsToContext';
 
695
function AuthzGetInformationFromContext; external authzlib name 'AuthzGetInformationFromContext';
 
696
function AuthzFreeContext; external authzlib name 'AuthzFreeContext';
 
697
function AuthzInitializeObjectAccessAuditEvent; external authzlib name 'AuthzInitializeObjectAccessAuditEvent';
 
698
function AuthzInitializeObjectAccessAuditEvent2; external authzlib name 'AuthzInitializeObjectAccessAuditEvent2';
 
699
function AuthzGetInformationFromAuditEvent; external authzlib name 'AuthzGetInformationFromAuditEvent';
 
700
function AuthzFreeAuditEvent; external authzlib name 'AuthzFreeAuditEvent';
 
701
 
 
702
{$ENDIF DYNAMIC_LINK}
 
703
 
 
704
end.