winsafer.h
上传用户:dzyhzl
上传日期:2019-04-29
资源大小:56270k
文件大小:15k
源码类别:

模拟服务器

开发平台:

C/C++

  1. /*++
  2. Copyright (c) 1997-2001  Microsoft Corporation
  3. Module Name:
  4.     winsafer.h
  5. Abstract:
  6.     This file implements the publicly exported functions, data types,
  7.     data structures, and definitions usable by programs that directly
  8.     interact with the Windows SAFER APIs.
  9. --*/
  10. #ifndef _WINSAFER_H
  11. #define _WINSAFER_H
  12. #include <guiddef.h>        
  13. #include <wincrypt.h>      
  14. #ifdef __cplusplus
  15. extern "C" {
  16. #endif
  17. //
  18. // Opaque datatype for representing handles to Safer objects.
  19. //
  20. DECLARE_HANDLE(SAFER_LEVEL_HANDLE);
  21. //
  22. // Constants to represent scope with SaferCreateLevel and others.
  23. //
  24. #define SAFER_SCOPEID_MACHINE  1
  25. #define SAFER_SCOPEID_USER     2
  26. //
  27. // Pre-defined levels that can be used with SaferCreateLevel
  28. //
  29. #define SAFER_LEVELID_FULLYTRUSTED 0x40000
  30. #define SAFER_LEVELID_NORMALUSER   0x20000
  31. #define SAFER_LEVELID_CONSTRAINED  0x10000
  32. #define SAFER_LEVELID_UNTRUSTED    0x01000 
  33. #define SAFER_LEVELID_DISALLOWED   0x00000
  34. //
  35. // Flags to use when creating/opening a Level with SaferCreateLevel
  36. //
  37. #define SAFER_LEVEL_OPEN   1
  38. //
  39. // Maximum string size.
  40. //
  41. #define SAFER_MAX_FRIENDLYNAME_SIZE 256
  42. #define SAFER_MAX_DESCRIPTION_SIZE  256
  43. #define SAFER_MAX_HASH_SIZE         64
  44. //
  45. // Flags to use with SaferComputeTokenFromLevel.
  46. //
  47. #define SAFER_TOKEN_NULL_IF_EQUAL   0x00000001
  48. #define SAFER_TOKEN_COMPARE_ONLY    0x00000002
  49. #define SAFER_TOKEN_MAKE_INERT      0x00000004
  50. #define SAFER_TOKEN_WANT_FLAGS      0x00000008
  51. //
  52. // Flags for specifying what criteria within SAFER_CODE_PROPERTIES to evaluate
  53. // when finding code identity with SaferIdentifyLevel.
  54. //
  55. #define SAFER_CRITERIA_IMAGEPATH    0x00001
  56. #define SAFER_CRITERIA_IMAGEHASH    0x00004
  57. #define SAFER_CRITERIA_AUTHENTICODE 0x00008
  58. #define SAFER_CRITERIA_URLZONE      0x00010
  59. #define SAFER_CRITERIA_IMAGEPATH_NT 0x01000
  60. //
  61. // Code image information structure passed to SaferIdentifyLevel.
  62. //
  63. #include <pshpack8.h>
  64. typedef struct _SAFER_CODE_PROPERTIES
  65. {
  66.     //
  67.     // Must be initialized to be the size of this structure,
  68.     // for the purposes of future/backwards compatibility.
  69.     //
  70.     
  71.     DWORD cbSize;
  72.     //
  73.     // Must be initialized to the types of criteria that should
  74.     // be considered when evaluating this structure.  This can be
  75.     // a combination of the SAFER_CRITERIA_xxxx flags.  If not enough
  76.     // of the structure elements needed to evaluate the criteria
  77.     // types indicated were supplied, then some of those criteria
  78.     // flags may be silently ignored.  Specifying 0 for this value
  79.     // will cause the entire structure's contents to be ignored.
  80.     //
  81.     DWORD dwCheckFlags;
  82.     //
  83.     // Optionally specifies the fully-qualified path and filename
  84.     // to be used for discrimination checks based on the path.
  85.     // The ImagePath will additionally be used to open and read the
  86.     // file to identify any other discrimination criteria that was
  87.     // unsupplied in this structure.
  88.     //
  89.     
  90.     LPCWSTR ImagePath;
  91.     //
  92.     // Optionally specifies a file handle that has been opened to
  93.     // code image with at least GENERIC_READ access.  The handle will
  94.     // be used instead of explicitly opening the file again to compute
  95.     // other discrimination criteria that was unsupplied in this structure.
  96.     //
  97.     
  98.     HANDLE hImageFileHandle;
  99.     //
  100.     // Optionally specifies the pre-determined Internet Explorer
  101.     // security zone.  These enums are defined within urlmon.h
  102.     // For example: URLZONE_LOCAL_MACHINE, URLZONE_INTRANET,
  103.     //   URLZONE_TRUSTED, URLZONE_INTERNET, or URLZONE_UNTRUSTED.
  104.     //
  105.     
  106.     DWORD UrlZoneId;
  107.     //
  108.     // Optionally specifies the pre-computed hash of the image.
  109.     // The supplied hash is interpreted as being valid if ImageSize
  110.     // is non-zero and dwImageHashSize is non-zero and HashAlgorithm
  111.     // represents a valid hashing algorithm from wincrypt.h
  112.     //
  113.     // If the supplied hash fails to meet the conditions above, then
  114.     // the hash will be automatically computed against:
  115.     //      1) by using ImageSize and pByteBlock if both are non-zero.
  116.     //      2) by using hImageFileHandle if it is non-null.
  117.     //      3) by attempting to open ImagePath if it is non-null.
  118.     //
  119.     
  120.     BYTE ImageHash[SAFER_MAX_HASH_SIZE];
  121.     DWORD dwImageHashSize;
  122.     LARGE_INTEGER ImageSize;
  123.     ALG_ID HashAlgorithm;
  124.     //
  125.     // Optionally specifies a memory block of memory representing
  126.     // the image for which the trust is being requested for.  When
  127.     // this member is specified, ImageSize must also be supplied.
  128.     //
  129.     
  130.     LPBYTE pByteBlock;
  131.     //
  132.     // Optionally gives the arguments used for Authenticode signer
  133.     // certificate verification.  These arguments are supplied to the
  134.     // WinVerifyTrust() API and control the user-interface prompting
  135.     // to accept untrusted certificates.
  136.     //
  137.     
  138.     HWND hWndParent;
  139.     DWORD dwWVTUIChoice;
  140. } SAFER_CODE_PROPERTIES, *PSAFER_CODE_PROPERTIES;
  141. #include <poppack.h>
  142. //
  143. // Masks for the per-identity WinSafer flags
  144. //
  145. #define SAFER_POLICY_JOBID_MASK       0xFF000000
  146. #define SAFER_POLICY_JOBID_CONSTRAINED           0x04000000
  147. #define SAFER_POLICY_JOBID_UNTRUSTED             0x03000000
  148. #define SAFER_POLICY_ONLY_EXES                   0x00010000  
  149. #define SAFER_POLICY_SANDBOX_INERT               0x00020000
  150. #define SAFER_POLICY_UIFLAGS_MASK                0x000000FF 
  151. #define SAFER_POLICY_UIFLAGS_INFORMATION_PROMPT  0x00000001
  152. #define SAFER_POLICY_UIFLAGS_OPTION_PROMPT       0x00000002
  153. //
  154. // Information classes on the overall policy that can be queried
  155. // with SaferSet/GetPolicyInformation and set at different
  156. // policy scopes based on access of the caller.
  157. //
  158. typedef enum _SAFER_POLICY_INFO_CLASS
  159. {
  160.     //
  161.     // Accesses the list of all Levels defined in a policy.
  162.     // The corresponding data element is a buffer that is filled
  163.     // with multiple DWORDs, each representing the LevelIds that
  164.     // are defined within this scope.
  165.     //
  166.     
  167.     SaferPolicyLevelList = 1,
  168.     //
  169.     // for transparent enforcement of policy in the execution
  170.     // framework -- will be used by native code execution but can
  171.     // be used by any policy enforcement environment.
  172.     // Corresponding data element is a DWORD holding a Boolean value.
  173.     //
  174.     
  175.     SaferPolicyEnableTransparentEnforcement,
  176.     //
  177.     // Returns the name of the Level that has been designed
  178.     // as the default level within the specified scope.
  179.     // The corresponding data element is a single DWORD buffer
  180.     // representing the LevelId of the default Level.  If no
  181.     // level has been configured to be the default, then the
  182.     // GetInfo API will return FALSE and GetLastError will
  183.     // return ERROR_NOT_FOUND.
  184.     //
  185.     
  186.     SaferPolicyDefaultLevel,
  187.     //
  188.     // Returns whether Code Identities or Default Level within the
  189.     // user scope can be considered during identification.
  190.     //
  191.     
  192.     SaferPolicyEvaluateUserScope,
  193.     
  194.     //
  195.     // Control Flags for for safer policy scope.
  196.     //
  197.     
  198.     SaferPolicyScopeFlags
  199. } SAFER_POLICY_INFO_CLASS;
  200. //
  201. // Enumerations used for retrieving specific information about a
  202. // single authorization Level via SaferGet/SetInformationFromLevel.
  203. //
  204. typedef enum _SAFER_OBJECT_INFO_CLASS 
  205. {
  206.     SaferObjectLevelId = 1,               // get: DWORD
  207.     SaferObjectScopeId,                   // get: DWORD
  208.     SaferObjectFriendlyName,              // get/set: LPCWSTR 
  209.     SaferObjectDescription,               // get/set: LPCWSTR
  210.     SaferObjectBuiltin,                   // get: DWORD boolean
  211.     SaferObjectDisallowed,                // get: DWORD boolean
  212.     SaferObjectDisableMaxPrivilege,       // get: DWORD boolean
  213.     SaferObjectInvertDeletedPrivileges,   // get: DWORD boolean
  214.     SaferObjectDeletedPrivileges,         // get: TOKEN_PRIVILEGES
  215.     SaferObjectDefaultOwner,              // get: TOKEN_OWNER
  216.     SaferObjectSidsToDisable,             // get: TOKEN_GROUPS
  217.     SaferObjectRestrictedSidsInverted,    // get: TOKEN_GROUPS
  218.     SaferObjectRestrictedSidsAdded,       // get: TOKEN_GROUPS
  219.     //
  220.     // To enumerate all identities, call GetInfo with
  221.     //      SaferObjectAllIdentificationGuids.
  222.     //
  223.     
  224.     SaferObjectAllIdentificationGuids,    // get: SAFER_IDENTIFICATION_GUIDS
  225.     //
  226.     // To create a new identity, call SetInfo with
  227.     //      SaferObjectSingleIdentification with a new
  228.     //      unique GUID that you have generated.
  229.     // To get details on a single identity, call GetInfo with
  230.     //      SaferObjectSingleIdentification with desired GUID.
  231.     // To modify details of a single identity, call SetInfo with
  232.     //      SaferObjectSingleIdentification with desired info and GUID.
  233.     // To delete an identity, call SetInfo with
  234.     //      SaferObjectSingleIdentification with the
  235.     //      header.dwIdentificationType set to 0.
  236.     //
  237.     
  238.     SaferObjectSingleIdentification,      // get/set: SAFER_IDENTIFICATION_*
  239.     SaferObjectExtendedError              // get: DWORD dwError
  240. } SAFER_OBJECT_INFO_CLASS;
  241. //
  242. // Structures and enums used by the SaferGet/SetLevelInformation APIs.
  243. //
  244. #include <pshpack8.h>
  245. typedef enum _SAFER_IDENTIFICATION_TYPES 
  246. {
  247.     SaferIdentityDefault,
  248.     SaferIdentityTypeImageName = 1,
  249.     SaferIdentityTypeImageHash,
  250.     SaferIdentityTypeUrlZone,
  251.     SaferIdentityTypeCertificate
  252. } SAFER_IDENTIFICATION_TYPES;
  253. typedef struct _SAFER_IDENTIFICATION_HEADER 
  254. {
  255.     //
  256.     // indicates the type of the structure, one of SaferIdentityType*
  257.     //
  258.     
  259.     SAFER_IDENTIFICATION_TYPES dwIdentificationType;
  260.     //
  261.     // size of the whole structure, not just the common header.
  262.     //
  263.     DWORD cbStructSize;
  264.     //
  265.     // the unique GUID of the Identity in question.
  266.     //
  267.     GUID IdentificationGuid;
  268.     //
  269.     // last change of this identification.
  270.     //
  271.     FILETIME lastModified;
  272. } SAFER_IDENTIFICATION_HEADER, *PSAFER_IDENTIFICATION_HEADER;
  273. typedef struct _SAFER_PATHNAME_IDENTIFICATION
  274. {
  275.     //
  276.     // header.dwIdentificationType must be SaferIdentityTypeImageName
  277.     // header.cbStructSize must be sizeof(SAFER_PATHNAME_IDENTIFICATION)
  278.     //
  279.     
  280.     SAFER_IDENTIFICATION_HEADER header;
  281.     //
  282.     // user-entered description
  283.     //
  284.     
  285.     WCHAR Description[SAFER_MAX_DESCRIPTION_SIZE];
  286.     //
  287.     // filepath or name, possibly with vars
  288.     //
  289.     
  290.     PWCHAR ImageName;
  291.     //
  292.     // any combo of SAFER_POL_SAFERFLAGS_*
  293.     //
  294.     
  295.     DWORD dwSaferFlags;
  296. } SAFER_PATHNAME_IDENTIFICATION, *PSAFER_PATHNAME_IDENTIFICATION;
  297. typedef struct _SAFER_HASH_IDENTIFICATION
  298. {
  299.     //
  300.     // header.dwIdentificationType must be SaferIdentityTypeImageHash
  301.     // header.cbStructSize must be sizeof(SAFER_HASH_IDENTIFICATION)
  302.     //
  303.     
  304.     SAFER_IDENTIFICATION_HEADER header;
  305.     //
  306.     // user-entered friendly name, initially from file's resources.
  307.     //
  308.     WCHAR Description[SAFER_MAX_DESCRIPTION_SIZE];
  309.     //
  310.     // user-entered description.
  311.     //
  312.     WCHAR FriendlyName[SAFER_MAX_FRIENDLYNAME_SIZE];
  313.     //
  314.     // amount of ImageHash actually used, in bytes (MD5 is 16 bytes).
  315.     //
  316.     DWORD HashSize;
  317.     //
  318.     // computed hash data itself.
  319.     //
  320.     BYTE ImageHash[SAFER_MAX_HASH_SIZE];
  321.     //
  322.     // algorithm in which the hash was computed (CALG_MD5, etc).
  323.     //
  324.     ALG_ID HashAlgorithm;
  325.     //
  326.     // size of the original file in bytes.
  327.     //
  328.     LARGE_INTEGER ImageSize;
  329.     //
  330.     // any combo of SAFER_POL_SAFERFLAGS_*
  331.     //
  332.     DWORD dwSaferFlags;
  333. } SAFER_HASH_IDENTIFICATION, *PSAFER_HASH_IDENTIFICATION;
  334. typedef struct _SAFER_URLZONE_IDENTIFICATION
  335. {
  336.     //
  337.     // header.dwIdentificationType must be SaferIdentityTypeUrlZone
  338.     // header.cbStructSize must be sizeof(SAFER_URLZONE_IDENTIFICATION)
  339.     //
  340.     
  341.     SAFER_IDENTIFICATION_HEADER header;
  342.     //
  343.     // any single URLZONE_* from urlmon.h
  344.     //
  345.     DWORD UrlZoneId;
  346.     //
  347.     // any combo of SAFER_POLICY_*
  348.     //
  349.     DWORD dwSaferFlags;
  350. } SAFER_URLZONE_IDENTIFICATION, *PSAFER_URLZONE_IDENTIFICATION;
  351. #include <poppack.h>
  352. //
  353. // Functions related to querying and setting the global policy
  354. // controls to disable transparent enforcement, and perform level
  355. // enumeration operations.
  356. //
  357. WINADVAPI
  358. BOOL WINAPI
  359. SaferGetPolicyInformation(
  360.     IN DWORD                   dwScopeId,
  361.     IN SAFER_POLICY_INFO_CLASS SaferPolicyInfoClass,
  362.     IN DWORD                   InfoBufferSize,
  363.     IN OUT PVOID               InfoBuffer,
  364.     IN OUT PDWORD              InfoBufferRetSize,
  365.     IN LPVOID                  lpReserved
  366.     );
  367. WINADVAPI
  368. BOOL WINAPI
  369. SaferSetPolicyInformation(
  370.     IN DWORD                   dwScopeId,
  371.     IN SAFER_POLICY_INFO_CLASS SaferPolicyInfoClass,
  372.     IN DWORD                   InfoBufferSize,
  373.     IN PVOID                   InfoBuffer,
  374.     IN LPVOID                  lpReserved
  375.     );
  376. //
  377. // Functions to open or close a handle to a Safer Level.
  378. //
  379. WINADVAPI
  380. BOOL WINAPI
  381. SaferCreateLevel(
  382.     IN  DWORD                dwScopeId,
  383.     IN  DWORD                dwLevelId,
  384.     IN  DWORD                OpenFlags,
  385.     OUT SAFER_LEVEL_HANDLE * pLevelHandle,
  386.     IN  LPVOID               lpReserved
  387.     );
  388. WINADVAPI
  389. BOOL WINAPI
  390. SaferCloseLevel(
  391.     IN SAFER_LEVEL_HANDLE hLevelHandle
  392.     );
  393. WINADVAPI
  394. BOOL WINAPI
  395. SaferIdentifyLevel(
  396.     IN  DWORD                    dwNumProperties,
  397.     IN  PSAFER_CODE_PROPERTIES   pCodeProperties,
  398.     OUT SAFER_LEVEL_HANDLE     * pLevelHandle,
  399.     IN  LPVOID                   lpReserved
  400.     );
  401. WINADVAPI
  402. BOOL WINAPI
  403. SaferComputeTokenFromLevel(
  404.     IN  SAFER_LEVEL_HANDLE LevelHandle,
  405.     IN  HANDLE             InAccessToken   OPTIONAL,
  406.     OUT PHANDLE            OutAccessToken,
  407.     IN  DWORD              dwFlags,
  408.     IN  LPVOID             lpReserved
  409.     );
  410. WINADVAPI
  411. BOOL WINAPI
  412. SaferGetLevelInformation(
  413.         IN  SAFER_LEVEL_HANDLE      LevelHandle,
  414.         IN  SAFER_OBJECT_INFO_CLASS dwInfoType,
  415.         OUT LPVOID                  lpQueryBuffer     OPTIONAL,
  416.         IN  DWORD                   dwInBufferSize,
  417.         OUT LPDWORD                 lpdwOutBufferSize
  418.         );
  419. WINADVAPI
  420. BOOL WINAPI
  421. SaferSetLevelInformation(
  422.     IN SAFER_LEVEL_HANDLE      LevelHandle,
  423.     IN SAFER_OBJECT_INFO_CLASS dwInfoType,
  424.     IN LPVOID                  lpQueryBuffer,
  425.     IN DWORD                   dwInBufferSize
  426.     );
  427. //
  428. // This function performs logging of messages to the Application 
  429. // event log.  This is called by the hooks within CreateProcess, 
  430. // ShellExecute and cmd when a lower trust evaluation result occurs.
  431. //
  432. WINADVAPI
  433. BOOL WINAPI
  434. SaferRecordEventLogEntry(
  435.     IN SAFER_LEVEL_HANDLE hLevel,
  436.     IN LPCWSTR            szTargetPath,
  437.     IN LPVOID             lpReserved
  438.     );
  439. #ifdef __cplusplus
  440. }
  441. #endif
  442. #endif