| // Copyright 2012 The Go Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style | |
| // license that can be found in the LICENSE file. | |
| package windows | |
| import ( | |
| "syscall" | |
| "unsafe" | |
| ) | |
| const ( | |
| NameUnknown = 0 | |
| NameFullyQualifiedDN = 1 | |
| NameSamCompatible = 2 | |
| NameDisplay = 3 | |
| NameUniqueId = 6 | |
| NameCanonical = 7 | |
| NameUserPrincipal = 8 | |
| NameCanonicalEx = 9 | |
| NameServicePrincipal = 10 | |
| NameDnsDomain = 12 | |
| ) | |
| // This function returns 1 byte BOOLEAN rather than the 4 byte BOOL. | |
| // http://blogs.msdn.com/b/drnick/archive/2007/12/19/windows-and-upn-format-credentials.aspx | |
| //sys TranslateName(accName *uint16, accNameFormat uint32, desiredNameFormat uint32, translatedName *uint16, nSize *uint32) (err error) [failretval&0xff==0] = secur32.TranslateNameW | |
| //sys GetUserNameEx(nameFormat uint32, nameBuffre *uint16, nSize *uint32) (err error) [failretval&0xff==0] = secur32.GetUserNameExW | |
| // TranslateAccountName converts a directory service | |
| // object name from one format to another. | |
| func TranslateAccountName(username string, from, to uint32, initSize int) (string, error) { | |
| u, e := UTF16PtrFromString(username) | |
| if e != nil { | |
| return "", e | |
| } | |
| n := uint32(50) | |
| for { | |
| b := make([]uint16, n) | |
| e = TranslateName(u, from, to, &b[0], &n) | |
| if e == nil { | |
| return UTF16ToString(b[:n]), nil | |
| } | |
| if e != ERROR_INSUFFICIENT_BUFFER { | |
| return "", e | |
| } | |
| if n <= uint32(len(b)) { | |
| return "", e | |
| } | |
| } | |
| } | |
| const ( | |
| // do not reorder | |
| NetSetupUnknownStatus = iota | |
| NetSetupUnjoined | |
| NetSetupWorkgroupName | |
| NetSetupDomainName | |
| ) | |
| type UserInfo10 struct { | |
| Name *uint16 | |
| Comment *uint16 | |
| UsrComment *uint16 | |
| FullName *uint16 | |
| } | |
| //sys NetUserGetInfo(serverName *uint16, userName *uint16, level uint32, buf **byte) (neterr error) = netapi32.NetUserGetInfo | |
| //sys NetGetJoinInformation(server *uint16, name **uint16, bufType *uint32) (neterr error) = netapi32.NetGetJoinInformation | |
| //sys NetApiBufferFree(buf *byte) (neterr error) = netapi32.NetApiBufferFree | |
| //sys NetUserEnum(serverName *uint16, level uint32, filter uint32, buf **byte, prefMaxLen uint32, entriesRead *uint32, totalEntries *uint32, resumeHandle *uint32) (neterr error) = netapi32.NetUserEnum | |
| const ( | |
| // do not reorder | |
| SidTypeUser = 1 + iota | |
| SidTypeGroup | |
| SidTypeDomain | |
| SidTypeAlias | |
| SidTypeWellKnownGroup | |
| SidTypeDeletedAccount | |
| SidTypeInvalid | |
| SidTypeUnknown | |
| SidTypeComputer | |
| SidTypeLabel | |
| ) | |
| type SidIdentifierAuthority struct { | |
| Value [6]byte | |
| } | |
| var ( | |
| SECURITY_NULL_SID_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 0}} | |
| SECURITY_WORLD_SID_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 1}} | |
| SECURITY_LOCAL_SID_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 2}} | |
| SECURITY_CREATOR_SID_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 3}} | |
| SECURITY_NON_UNIQUE_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 4}} | |
| SECURITY_NT_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 5}} | |
| SECURITY_MANDATORY_LABEL_AUTHORITY = SidIdentifierAuthority{[6]byte{0, 0, 0, 0, 0, 16}} | |
| ) | |
| const ( | |
| SECURITY_NULL_RID = 0 | |
| SECURITY_WORLD_RID = 0 | |
| SECURITY_LOCAL_RID = 0 | |
| SECURITY_CREATOR_OWNER_RID = 0 | |
| SECURITY_CREATOR_GROUP_RID = 1 | |
| SECURITY_DIALUP_RID = 1 | |
| SECURITY_NETWORK_RID = 2 | |
| SECURITY_BATCH_RID = 3 | |
| SECURITY_INTERACTIVE_RID = 4 | |
| SECURITY_LOGON_IDS_RID = 5 | |
| SECURITY_SERVICE_RID = 6 | |
| SECURITY_LOCAL_SYSTEM_RID = 18 | |
| SECURITY_BUILTIN_DOMAIN_RID = 32 | |
| SECURITY_PRINCIPAL_SELF_RID = 10 | |
| SECURITY_CREATOR_OWNER_SERVER_RID = 0x2 | |
| SECURITY_CREATOR_GROUP_SERVER_RID = 0x3 | |
| SECURITY_LOGON_IDS_RID_COUNT = 0x3 | |
| SECURITY_ANONYMOUS_LOGON_RID = 0x7 | |
| SECURITY_PROXY_RID = 0x8 | |
| SECURITY_ENTERPRISE_CONTROLLERS_RID = 0x9 | |
| SECURITY_SERVER_LOGON_RID = SECURITY_ENTERPRISE_CONTROLLERS_RID | |
| SECURITY_AUTHENTICATED_USER_RID = 0xb | |
| SECURITY_RESTRICTED_CODE_RID = 0xc | |
| SECURITY_NT_NON_UNIQUE_RID = 0x15 | |
| ) | |
| // Predefined domain-relative RIDs for local groups. | |
| // See https://msdn.microsoft.com/en-us/library/windows/desktop/aa379649(v=vs.85).aspx | |
| const ( | |
| DOMAIN_ALIAS_RID_ADMINS = 0x220 | |
| DOMAIN_ALIAS_RID_USERS = 0x221 | |
| DOMAIN_ALIAS_RID_GUESTS = 0x222 | |
| DOMAIN_ALIAS_RID_POWER_USERS = 0x223 | |
| DOMAIN_ALIAS_RID_ACCOUNT_OPS = 0x224 | |
| DOMAIN_ALIAS_RID_SYSTEM_OPS = 0x225 | |
| DOMAIN_ALIAS_RID_PRINT_OPS = 0x226 | |
| DOMAIN_ALIAS_RID_BACKUP_OPS = 0x227 | |
| DOMAIN_ALIAS_RID_REPLICATOR = 0x228 | |
| DOMAIN_ALIAS_RID_RAS_SERVERS = 0x229 | |
| DOMAIN_ALIAS_RID_PREW2KCOMPACCESS = 0x22a | |
| DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS = 0x22b | |
| DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS = 0x22c | |
| DOMAIN_ALIAS_RID_INCOMING_FOREST_TRUST_BUILDERS = 0x22d | |
| DOMAIN_ALIAS_RID_MONITORING_USERS = 0x22e | |
| DOMAIN_ALIAS_RID_LOGGING_USERS = 0x22f | |
| DOMAIN_ALIAS_RID_AUTHORIZATIONACCESS = 0x230 | |
| DOMAIN_ALIAS_RID_TS_LICENSE_SERVERS = 0x231 | |
| DOMAIN_ALIAS_RID_DCOM_USERS = 0x232 | |
| DOMAIN_ALIAS_RID_IUSERS = 0x238 | |
| DOMAIN_ALIAS_RID_CRYPTO_OPERATORS = 0x239 | |
| DOMAIN_ALIAS_RID_CACHEABLE_PRINCIPALS_GROUP = 0x23b | |
| DOMAIN_ALIAS_RID_NON_CACHEABLE_PRINCIPALS_GROUP = 0x23c | |
| DOMAIN_ALIAS_RID_EVENT_LOG_READERS_GROUP = 0x23d | |
| DOMAIN_ALIAS_RID_CERTSVC_DCOM_ACCESS_GROUP = 0x23e | |
| ) | |
| //sys LookupAccountSid(systemName *uint16, sid *SID, name *uint16, nameLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) = advapi32.LookupAccountSidW | |
| //sys LookupAccountName(systemName *uint16, accountName *uint16, sid *SID, sidLen *uint32, refdDomainName *uint16, refdDomainNameLen *uint32, use *uint32) (err error) = advapi32.LookupAccountNameW | |
| //sys ConvertSidToStringSid(sid *SID, stringSid **uint16) (err error) = advapi32.ConvertSidToStringSidW | |
| //sys ConvertStringSidToSid(stringSid *uint16, sid **SID) (err error) = advapi32.ConvertStringSidToSidW | |
| //sys GetLengthSid(sid *SID) (len uint32) = advapi32.GetLengthSid | |
| //sys CopySid(destSidLen uint32, destSid *SID, srcSid *SID) (err error) = advapi32.CopySid | |
| //sys AllocateAndInitializeSid(identAuth *SidIdentifierAuthority, subAuth byte, subAuth0 uint32, subAuth1 uint32, subAuth2 uint32, subAuth3 uint32, subAuth4 uint32, subAuth5 uint32, subAuth6 uint32, subAuth7 uint32, sid **SID) (err error) = advapi32.AllocateAndInitializeSid | |
| //sys createWellKnownSid(sidType WELL_KNOWN_SID_TYPE, domainSid *SID, sid *SID, sizeSid *uint32) (err error) = advapi32.CreateWellKnownSid | |
| //sys isWellKnownSid(sid *SID, sidType WELL_KNOWN_SID_TYPE) (isWellKnown bool) = advapi32.IsWellKnownSid | |
| //sys FreeSid(sid *SID) (err error) [failretval!=0] = advapi32.FreeSid | |
| //sys EqualSid(sid1 *SID, sid2 *SID) (isEqual bool) = advapi32.EqualSid | |
| //sys getSidIdentifierAuthority(sid *SID) (authority *SidIdentifierAuthority) = advapi32.GetSidIdentifierAuthority | |
| //sys getSidSubAuthorityCount(sid *SID) (count *uint8) = advapi32.GetSidSubAuthorityCount | |
| //sys getSidSubAuthority(sid *SID, index uint32) (subAuthority *uint32) = advapi32.GetSidSubAuthority | |
| //sys isValidSid(sid *SID) (isValid bool) = advapi32.IsValidSid | |
| // The security identifier (SID) structure is a variable-length | |
| // structure used to uniquely identify users or groups. | |
| type SID struct{} | |
| // StringToSid converts a string-format security identifier | |
| // SID into a valid, functional SID. | |
| func StringToSid(s string) (*SID, error) { | |
| var sid *SID | |
| p, e := UTF16PtrFromString(s) | |
| if e != nil { | |
| return nil, e | |
| } | |
| e = ConvertStringSidToSid(p, &sid) | |
| if e != nil { | |
| return nil, e | |
| } | |
| defer LocalFree((Handle)(unsafe.Pointer(sid))) | |
| return sid.Copy() | |
| } | |
| // LookupSID retrieves a security identifier SID for the account | |
| // and the name of the domain on which the account was found. | |
| // System specify target computer to search. | |
| func LookupSID(system, account string) (sid *SID, domain string, accType uint32, err error) { | |
| if len(account) == 0 { | |
| return nil, "", 0, syscall.EINVAL | |
| } | |
| acc, e := UTF16PtrFromString(account) | |
| if e != nil { | |
| return nil, "", 0, e | |
| } | |
| var sys *uint16 | |
| if len(system) > 0 { | |
| sys, e = UTF16PtrFromString(system) | |
| if e != nil { | |
| return nil, "", 0, e | |
| } | |
| } | |
| n := uint32(50) | |
| dn := uint32(50) | |
| for { | |
| b := make([]byte, n) | |
| db := make([]uint16, dn) | |
| sid = (*SID)(unsafe.Pointer(&b[0])) | |
| e = LookupAccountName(sys, acc, sid, &n, &db[0], &dn, &accType) | |
| if e == nil { | |
| return sid, UTF16ToString(db), accType, nil | |
| } | |
| if e != ERROR_INSUFFICIENT_BUFFER { | |
| return nil, "", 0, e | |
| } | |
| if n <= uint32(len(b)) { | |
| return nil, "", 0, e | |
| } | |
| } | |
| } | |
| // String converts SID to a string format suitable for display, storage, or transmission. | |
| func (sid *SID) String() string { | |
| var s *uint16 | |
| e := ConvertSidToStringSid(sid, &s) | |
| if e != nil { | |
| return "" | |
| } | |
| defer LocalFree((Handle)(unsafe.Pointer(s))) | |
| return UTF16ToString((*[256]uint16)(unsafe.Pointer(s))[:]) | |
| } | |
| // Len returns the length, in bytes, of a valid security identifier SID. | |
| func (sid *SID) Len() int { | |
| return int(GetLengthSid(sid)) | |
| } | |
| // Copy creates a duplicate of security identifier SID. | |
| func (sid *SID) Copy() (*SID, error) { | |
| b := make([]byte, sid.Len()) | |
| sid2 := (*SID)(unsafe.Pointer(&b[0])) | |
| e := CopySid(uint32(len(b)), sid2, sid) | |
| if e != nil { | |
| return nil, e | |
| } | |
| return sid2, nil | |
| } | |
| // IdentifierAuthority returns the identifier authority of the SID. | |
| func (sid *SID) IdentifierAuthority() SidIdentifierAuthority { | |
| return *getSidIdentifierAuthority(sid) | |
| } | |
| // SubAuthorityCount returns the number of sub-authorities in the SID. | |
| func (sid *SID) SubAuthorityCount() uint8 { | |
| return *getSidSubAuthorityCount(sid) | |
| } | |
| // SubAuthority returns the sub-authority of the SID as specified by | |
| // the index, which must be less than sid.SubAuthorityCount(). | |
| func (sid *SID) SubAuthority(idx uint32) uint32 { | |
| if idx >= uint32(sid.SubAuthorityCount()) { | |
| panic("sub-authority index out of range") | |
| } | |
| return *getSidSubAuthority(sid, idx) | |
| } | |
| // IsValid returns whether the SID has a valid revision and length. | |
| func (sid *SID) IsValid() bool { | |
| return isValidSid(sid) | |
| } | |
| // Equals compares two SIDs for equality. | |
| func (sid *SID) Equals(sid2 *SID) bool { | |
| return EqualSid(sid, sid2) | |
| } | |
| // IsWellKnown determines whether the SID matches the well-known sidType. | |
| func (sid *SID) IsWellKnown(sidType WELL_KNOWN_SID_TYPE) bool { | |
| return isWellKnownSid(sid, sidType) | |
| } | |
| // LookupAccount retrieves the name of the account for this SID | |
| // and the name of the first domain on which this SID is found. | |
| // System specify target computer to search for. | |
| func (sid *SID) LookupAccount(system string) (account, domain string, accType uint32, err error) { | |
| var sys *uint16 | |
| if len(system) > 0 { | |
| sys, err = UTF16PtrFromString(system) | |
| if err != nil { | |
| return "", "", 0, err | |
| } | |
| } | |
| n := uint32(50) | |
| dn := uint32(50) | |
| for { | |
| b := make([]uint16, n) | |
| db := make([]uint16, dn) | |
| e := LookupAccountSid(sys, sid, &b[0], &n, &db[0], &dn, &accType) | |
| if e == nil { | |
| return UTF16ToString(b), UTF16ToString(db), accType, nil | |
| } | |
| if e != ERROR_INSUFFICIENT_BUFFER { | |
| return "", "", 0, e | |
| } | |
| if n <= uint32(len(b)) { | |
| return "", "", 0, e | |
| } | |
| } | |
| } | |
| // Various types of pre-specified SIDs that can be synthesized and compared at runtime. | |
| type WELL_KNOWN_SID_TYPE uint32 | |
| const ( | |
| WinNullSid = 0 | |
| WinWorldSid = 1 | |
| WinLocalSid = 2 | |
| WinCreatorOwnerSid = 3 | |
| WinCreatorGroupSid = 4 | |
| WinCreatorOwnerServerSid = 5 | |
| WinCreatorGroupServerSid = 6 | |
| WinNtAuthoritySid = 7 | |
| WinDialupSid = 8 | |
| WinNetworkSid = 9 | |
| WinBatchSid = 10 | |
| WinInteractiveSid = 11 | |
| WinServiceSid = 12 | |
| WinAnonymousSid = 13 | |
| WinProxySid = 14 | |
| WinEnterpriseControllersSid = 15 | |
| WinSelfSid = 16 | |
| WinAuthenticatedUserSid = 17 | |
| WinRestrictedCodeSid = 18 | |
| WinTerminalServerSid = 19 | |
| WinRemoteLogonIdSid = 20 | |
| WinLogonIdsSid = 21 | |
| WinLocalSystemSid = 22 | |
| WinLocalServiceSid = 23 | |
| WinNetworkServiceSid = 24 | |
| WinBuiltinDomainSid = 25 | |
| WinBuiltinAdministratorsSid = 26 | |
| WinBuiltinUsersSid = 27 | |
| WinBuiltinGuestsSid = 28 | |
| WinBuiltinPowerUsersSid = 29 | |
| WinBuiltinAccountOperatorsSid = 30 | |
| WinBuiltinSystemOperatorsSid = 31 | |
| WinBuiltinPrintOperatorsSid = 32 | |
| WinBuiltinBackupOperatorsSid = 33 | |
| WinBuiltinReplicatorSid = 34 | |
| WinBuiltinPreWindows2000CompatibleAccessSid = 35 | |
| WinBuiltinRemoteDesktopUsersSid = 36 | |
| WinBuiltinNetworkConfigurationOperatorsSid = 37 | |
| WinAccountAdministratorSid = 38 | |
| WinAccountGuestSid = 39 | |
| WinAccountKrbtgtSid = 40 | |
| WinAccountDomainAdminsSid = 41 | |
| WinAccountDomainUsersSid = 42 | |
| WinAccountDomainGuestsSid = 43 | |
| WinAccountComputersSid = 44 | |
| WinAccountControllersSid = 45 | |
| WinAccountCertAdminsSid = 46 | |
| WinAccountSchemaAdminsSid = 47 | |
| WinAccountEnterpriseAdminsSid = 48 | |
| WinAccountPolicyAdminsSid = 49 | |
| WinAccountRasAndIasServersSid = 50 | |
| WinNTLMAuthenticationSid = 51 | |
| WinDigestAuthenticationSid = 52 | |
| WinSChannelAuthenticationSid = 53 | |
| WinThisOrganizationSid = 54 | |
| WinOtherOrganizationSid = 55 | |
| WinBuiltinIncomingForestTrustBuildersSid = 56 | |
| WinBuiltinPerfMonitoringUsersSid = 57 | |
| WinBuiltinPerfLoggingUsersSid = 58 | |
| WinBuiltinAuthorizationAccessSid = 59 | |
| WinBuiltinTerminalServerLicenseServersSid = 60 | |
| WinBuiltinDCOMUsersSid = 61 | |
| WinBuiltinIUsersSid = 62 | |
| WinIUserSid = 63 | |
| WinBuiltinCryptoOperatorsSid = 64 | |
| WinUntrustedLabelSid = 65 | |
| WinLowLabelSid = 66 | |
| WinMediumLabelSid = 67 | |
| WinHighLabelSid = 68 | |
| WinSystemLabelSid = 69 | |
| WinWriteRestrictedCodeSid = 70 | |
| WinCreatorOwnerRightsSid = 71 | |
| WinCacheablePrincipalsGroupSid = 72 | |
| WinNonCacheablePrincipalsGroupSid = 73 | |
| WinEnterpriseReadonlyControllersSid = 74 | |
| WinAccountReadonlyControllersSid = 75 | |
| WinBuiltinEventLogReadersGroup = 76 | |
| WinNewEnterpriseReadonlyControllersSid = 77 | |
| WinBuiltinCertSvcDComAccessGroup = 78 | |
| WinMediumPlusLabelSid = 79 | |
| WinLocalLogonSid = 80 | |
| WinConsoleLogonSid = 81 | |
| WinThisOrganizationCertificateSid = 82 | |
| WinApplicationPackageAuthoritySid = 83 | |
| WinBuiltinAnyPackageSid = 84 | |
| WinCapabilityInternetClientSid = 85 | |
| WinCapabilityInternetClientServerSid = 86 | |
| WinCapabilityPrivateNetworkClientServerSid = 87 | |
| WinCapabilityPicturesLibrarySid = 88 | |
| WinCapabilityVideosLibrarySid = 89 | |
| WinCapabilityMusicLibrarySid = 90 | |
| WinCapabilityDocumentsLibrarySid = 91 | |
| WinCapabilitySharedUserCertificatesSid = 92 | |
| WinCapabilityEnterpriseAuthenticationSid = 93 | |
| WinCapabilityRemovableStorageSid = 94 | |
| WinBuiltinRDSRemoteAccessServersSid = 95 | |
| WinBuiltinRDSEndpointServersSid = 96 | |
| WinBuiltinRDSManagementServersSid = 97 | |
| WinUserModeDriversSid = 98 | |
| WinBuiltinHyperVAdminsSid = 99 | |
| WinAccountCloneableControllersSid = 100 | |
| WinBuiltinAccessControlAssistanceOperatorsSid = 101 | |
| WinBuiltinRemoteManagementUsersSid = 102 | |
| WinAuthenticationAuthorityAssertedSid = 103 | |
| WinAuthenticationServiceAssertedSid = 104 | |
| WinLocalAccountSid = 105 | |
| WinLocalAccountAndAdministratorSid = 106 | |
| WinAccountProtectedUsersSid = 107 | |
| WinCapabilityAppointmentsSid = 108 | |
| WinCapabilityContactsSid = 109 | |
| WinAccountDefaultSystemManagedSid = 110 | |
| WinBuiltinDefaultSystemManagedGroupSid = 111 | |
| WinBuiltinStorageReplicaAdminsSid = 112 | |
| WinAccountKeyAdminsSid = 113 | |
| WinAccountEnterpriseKeyAdminsSid = 114 | |
| WinAuthenticationKeyTrustSid = 115 | |
| WinAuthenticationKeyPropertyMFASid = 116 | |
| WinAuthenticationKeyPropertyAttestationSid = 117 | |
| WinAuthenticationFreshKeyAuthSid = 118 | |
| WinBuiltinDeviceOwnersSid = 119 | |
| ) | |
| // Creates a SID for a well-known predefined alias, generally using the constants of the form | |
| // Win*Sid, for the local machine. | |
| func CreateWellKnownSid(sidType WELL_KNOWN_SID_TYPE) (*SID, error) { | |
| return CreateWellKnownDomainSid(sidType, nil) | |
| } | |
| // Creates a SID for a well-known predefined alias, generally using the constants of the form | |
| // Win*Sid, for the domain specified by the domainSid parameter. | |
| func CreateWellKnownDomainSid(sidType WELL_KNOWN_SID_TYPE, domainSid *SID) (*SID, error) { | |
| n := uint32(50) | |
| for { | |
| b := make([]byte, n) | |
| sid := (*SID)(unsafe.Pointer(&b[0])) | |
| err := createWellKnownSid(sidType, domainSid, sid, &n) | |
| if err == nil { | |
| return sid, nil | |
| } | |
| if err != ERROR_INSUFFICIENT_BUFFER { | |
| return nil, err | |
| } | |
| if n <= uint32(len(b)) { | |
| return nil, err | |
| } | |
| } | |
| } | |
| const ( | |
| // do not reorder | |
| TOKEN_ASSIGN_PRIMARY = 1 << iota | |
| TOKEN_DUPLICATE | |
| TOKEN_IMPERSONATE | |
| TOKEN_QUERY | |
| TOKEN_QUERY_SOURCE | |
| TOKEN_ADJUST_PRIVILEGES | |
| TOKEN_ADJUST_GROUPS | |
| TOKEN_ADJUST_DEFAULT | |
| TOKEN_ADJUST_SESSIONID | |
| TOKEN_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | | |
| TOKEN_ASSIGN_PRIMARY | | |
| TOKEN_DUPLICATE | | |
| TOKEN_IMPERSONATE | | |
| TOKEN_QUERY | | |
| TOKEN_QUERY_SOURCE | | |
| TOKEN_ADJUST_PRIVILEGES | | |
| TOKEN_ADJUST_GROUPS | | |
| TOKEN_ADJUST_DEFAULT | | |
| TOKEN_ADJUST_SESSIONID | |
| TOKEN_READ = STANDARD_RIGHTS_READ | TOKEN_QUERY | |
| TOKEN_WRITE = STANDARD_RIGHTS_WRITE | | |
| TOKEN_ADJUST_PRIVILEGES | | |
| TOKEN_ADJUST_GROUPS | | |
| TOKEN_ADJUST_DEFAULT | |
| TOKEN_EXECUTE = STANDARD_RIGHTS_EXECUTE | |
| ) | |
| const ( | |
| // do not reorder | |
| TokenUser = 1 + iota | |
| TokenGroups | |
| TokenPrivileges | |
| TokenOwner | |
| TokenPrimaryGroup | |
| TokenDefaultDacl | |
| TokenSource | |
| TokenType | |
| TokenImpersonationLevel | |
| TokenStatistics | |
| TokenRestrictedSids | |
| TokenSessionId | |
| TokenGroupsAndPrivileges | |
| TokenSessionReference | |
| TokenSandBoxInert | |
| TokenAuditPolicy | |
| TokenOrigin | |
| TokenElevationType | |
| TokenLinkedToken | |
| TokenElevation | |
| TokenHasRestrictions | |
| TokenAccessInformation | |
| TokenVirtualizationAllowed | |
| TokenVirtualizationEnabled | |
| TokenIntegrityLevel | |
| TokenUIAccess | |
| TokenMandatoryPolicy | |
| TokenLogonSid | |
| MaxTokenInfoClass | |
| ) | |
| // Group attributes inside of Tokengroups.Groups[i].Attributes | |
| const ( | |
| SE_GROUP_MANDATORY = 0x00000001 | |
| SE_GROUP_ENABLED_BY_DEFAULT = 0x00000002 | |
| SE_GROUP_ENABLED = 0x00000004 | |
| SE_GROUP_OWNER = 0x00000008 | |
| SE_GROUP_USE_FOR_DENY_ONLY = 0x00000010 | |
| SE_GROUP_INTEGRITY = 0x00000020 | |
| SE_GROUP_INTEGRITY_ENABLED = 0x00000040 | |
| SE_GROUP_LOGON_ID = 0xC0000000 | |
| SE_GROUP_RESOURCE = 0x20000000 | |
| SE_GROUP_VALID_ATTRIBUTES = SE_GROUP_MANDATORY | SE_GROUP_ENABLED_BY_DEFAULT | SE_GROUP_ENABLED | SE_GROUP_OWNER | SE_GROUP_USE_FOR_DENY_ONLY | SE_GROUP_LOGON_ID | SE_GROUP_RESOURCE | SE_GROUP_INTEGRITY | SE_GROUP_INTEGRITY_ENABLED | |
| ) | |
| // Privilege attributes | |
| const ( | |
| SE_PRIVILEGE_ENABLED_BY_DEFAULT = 0x00000001 | |
| SE_PRIVILEGE_ENABLED = 0x00000002 | |
| SE_PRIVILEGE_REMOVED = 0x00000004 | |
| SE_PRIVILEGE_USED_FOR_ACCESS = 0x80000000 | |
| SE_PRIVILEGE_VALID_ATTRIBUTES = SE_PRIVILEGE_ENABLED_BY_DEFAULT | SE_PRIVILEGE_ENABLED | SE_PRIVILEGE_REMOVED | SE_PRIVILEGE_USED_FOR_ACCESS | |
| ) | |
| // Token types | |
| const ( | |
| TokenPrimary = 1 | |
| TokenImpersonation = 2 | |
| ) | |
| // Impersonation levels | |
| const ( | |
| SecurityAnonymous = 0 | |
| SecurityIdentification = 1 | |
| SecurityImpersonation = 2 | |
| SecurityDelegation = 3 | |
| ) | |
| type LUID struct { | |
| LowPart uint32 | |
| HighPart int32 | |
| } | |
| type LUIDAndAttributes struct { | |
| Luid LUID | |
| Attributes uint32 | |
| } | |
| type SIDAndAttributes struct { | |
| Sid *SID | |
| Attributes uint32 | |
| } | |
| type Tokenuser struct { | |
| User SIDAndAttributes | |
| } | |
| type Tokenprimarygroup struct { | |
| PrimaryGroup *SID | |
| } | |
| type Tokengroups struct { | |
| GroupCount uint32 | |
| Groups [1]SIDAndAttributes // Use AllGroups() for iterating. | |
| } | |
| // AllGroups returns a slice that can be used to iterate over the groups in g. | |
| func (g *Tokengroups) AllGroups() []SIDAndAttributes { | |
| return (*[(1 << 28) - 1]SIDAndAttributes)(unsafe.Pointer(&g.Groups[0]))[:g.GroupCount:g.GroupCount] | |
| } | |
| type Tokenprivileges struct { | |
| PrivilegeCount uint32 | |
| Privileges [1]LUIDAndAttributes // Use AllPrivileges() for iterating. | |
| } | |
| // AllPrivileges returns a slice that can be used to iterate over the privileges in p. | |
| func (p *Tokenprivileges) AllPrivileges() []LUIDAndAttributes { | |
| return (*[(1 << 27) - 1]LUIDAndAttributes)(unsafe.Pointer(&p.Privileges[0]))[:p.PrivilegeCount:p.PrivilegeCount] | |
| } | |
| type Tokenmandatorylabel struct { | |
| Label SIDAndAttributes | |
| } | |
| func (tml *Tokenmandatorylabel) Size() uint32 { | |
| return uint32(unsafe.Sizeof(Tokenmandatorylabel{})) + GetLengthSid(tml.Label.Sid) | |
| } | |
| // Authorization Functions | |
| //sys checkTokenMembership(tokenHandle Token, sidToCheck *SID, isMember *int32) (err error) = advapi32.CheckTokenMembership | |
| //sys isTokenRestricted(tokenHandle Token) (ret bool, err error) [!failretval] = advapi32.IsTokenRestricted | |
| //sys OpenProcessToken(process Handle, access uint32, token *Token) (err error) = advapi32.OpenProcessToken | |
| //sys OpenThreadToken(thread Handle, access uint32, openAsSelf bool, token *Token) (err error) = advapi32.OpenThreadToken | |
| //sys ImpersonateSelf(impersonationlevel uint32) (err error) = advapi32.ImpersonateSelf | |
| //sys RevertToSelf() (err error) = advapi32.RevertToSelf | |
| //sys SetThreadToken(thread *Handle, token Token) (err error) = advapi32.SetThreadToken | |
| //sys LookupPrivilegeValue(systemname *uint16, name *uint16, luid *LUID) (err error) = advapi32.LookupPrivilegeValueW | |
| //sys AdjustTokenPrivileges(token Token, disableAllPrivileges bool, newstate *Tokenprivileges, buflen uint32, prevstate *Tokenprivileges, returnlen *uint32) (err error) = advapi32.AdjustTokenPrivileges | |
| //sys AdjustTokenGroups(token Token, resetToDefault bool, newstate *Tokengroups, buflen uint32, prevstate *Tokengroups, returnlen *uint32) (err error) = advapi32.AdjustTokenGroups | |
| //sys GetTokenInformation(token Token, infoClass uint32, info *byte, infoLen uint32, returnedLen *uint32) (err error) = advapi32.GetTokenInformation | |
| //sys SetTokenInformation(token Token, infoClass uint32, info *byte, infoLen uint32) (err error) = advapi32.SetTokenInformation | |
| //sys DuplicateTokenEx(existingToken Token, desiredAccess uint32, tokenAttributes *SecurityAttributes, impersonationLevel uint32, tokenType uint32, newToken *Token) (err error) = advapi32.DuplicateTokenEx | |
| //sys GetUserProfileDirectory(t Token, dir *uint16, dirLen *uint32) (err error) = userenv.GetUserProfileDirectoryW | |
| //sys getSystemDirectory(dir *uint16, dirLen uint32) (len uint32, err error) = kernel32.GetSystemDirectoryW | |
| //sys getWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) = kernel32.GetWindowsDirectoryW | |
| //sys getSystemWindowsDirectory(dir *uint16, dirLen uint32) (len uint32, err error) = kernel32.GetSystemWindowsDirectoryW | |
| // An access token contains the security information for a logon session. | |
| // The system creates an access token when a user logs on, and every | |
| // process executed on behalf of the user has a copy of the token. | |
| // The token identifies the user, the user's groups, and the user's | |
| // privileges. The system uses the token to control access to securable | |
| // objects and to control the ability of the user to perform various | |
| // system-related operations on the local computer. | |
| type Token Handle | |
| // OpenCurrentProcessToken opens an access token associated with current | |
| // process with TOKEN_QUERY access. It is a real token that needs to be closed. | |
| // | |
| // Deprecated: Explicitly call OpenProcessToken(CurrentProcess(), ...) | |
| // with the desired access instead, or use GetCurrentProcessToken for a | |
| // TOKEN_QUERY token. | |
| func OpenCurrentProcessToken() (Token, error) { | |
| var token Token | |
| err := OpenProcessToken(CurrentProcess(), TOKEN_QUERY, &token) | |
| return token, err | |
| } | |
| // GetCurrentProcessToken returns the access token associated with | |
| // the current process. It is a pseudo token that does not need | |
| // to be closed. | |
| func GetCurrentProcessToken() Token { | |
| return Token(^uintptr(4 - 1)) | |
| } | |
| // GetCurrentThreadToken return the access token associated with | |
| // the current thread. It is a pseudo token that does not need | |
| // to be closed. | |
| func GetCurrentThreadToken() Token { | |
| return Token(^uintptr(5 - 1)) | |
| } | |
| // GetCurrentThreadEffectiveToken returns the effective access token | |
| // associated with the current thread. It is a pseudo token that does | |
| // not need to be closed. | |
| func GetCurrentThreadEffectiveToken() Token { | |
| return Token(^uintptr(6 - 1)) | |
| } | |
| // Close releases access to access token. | |
| func (t Token) Close() error { | |
| return CloseHandle(Handle(t)) | |
| } | |
| // getInfo retrieves a specified type of information about an access token. | |
| func (t Token) getInfo(class uint32, initSize int) (unsafe.Pointer, error) { | |
| n := uint32(initSize) | |
| for { | |
| b := make([]byte, n) | |
| e := GetTokenInformation(t, class, &b[0], uint32(len(b)), &n) | |
| if e == nil { | |
| return unsafe.Pointer(&b[0]), nil | |
| } | |
| if e != ERROR_INSUFFICIENT_BUFFER { | |
| return nil, e | |
| } | |
| if n <= uint32(len(b)) { | |
| return nil, e | |
| } | |
| } | |
| } | |
| // GetTokenUser retrieves access token t user account information. | |
| func (t Token) GetTokenUser() (*Tokenuser, error) { | |
| i, e := t.getInfo(TokenUser, 50) | |
| if e != nil { | |
| return nil, e | |
| } | |
| return (*Tokenuser)(i), nil | |
| } | |
| // GetTokenGroups retrieves group accounts associated with access token t. | |
| func (t Token) GetTokenGroups() (*Tokengroups, error) { | |
| i, e := t.getInfo(TokenGroups, 50) | |
| if e != nil { | |
| return nil, e | |
| } | |
| return (*Tokengroups)(i), nil | |
| } | |
| // GetTokenPrimaryGroup retrieves access token t primary group information. | |
| // A pointer to a SID structure representing a group that will become | |
| // the primary group of any objects created by a process using this access token. | |
| func (t Token) GetTokenPrimaryGroup() (*Tokenprimarygroup, error) { | |
| i, e := t.getInfo(TokenPrimaryGroup, 50) | |
| if e != nil { | |
| return nil, e | |
| } | |
| return (*Tokenprimarygroup)(i), nil | |
| } | |
| // GetUserProfileDirectory retrieves path to the | |
| // root directory of the access token t user's profile. | |
| func (t Token) GetUserProfileDirectory() (string, error) { | |
| n := uint32(100) | |
| for { | |
| b := make([]uint16, n) | |
| e := GetUserProfileDirectory(t, &b[0], &n) | |
| if e == nil { | |
| return UTF16ToString(b), nil | |
| } | |
| if e != ERROR_INSUFFICIENT_BUFFER { | |
| return "", e | |
| } | |
| if n <= uint32(len(b)) { | |
| return "", e | |
| } | |
| } | |
| } | |
| // IsElevated returns whether the current token is elevated from a UAC perspective. | |
| func (token Token) IsElevated() bool { | |
| var isElevated uint32 | |
| var outLen uint32 | |
| err := GetTokenInformation(token, TokenElevation, (*byte)(unsafe.Pointer(&isElevated)), uint32(unsafe.Sizeof(isElevated)), &outLen) | |
| if err != nil { | |
| return false | |
| } | |
| return outLen == uint32(unsafe.Sizeof(isElevated)) && isElevated != 0 | |
| } | |
| // GetLinkedToken returns the linked token, which may be an elevated UAC token. | |
| func (token Token) GetLinkedToken() (Token, error) { | |
| var linkedToken Token | |
| var outLen uint32 | |
| err := GetTokenInformation(token, TokenLinkedToken, (*byte)(unsafe.Pointer(&linkedToken)), uint32(unsafe.Sizeof(linkedToken)), &outLen) | |
| if err != nil { | |
| return Token(0), err | |
| } | |
| return linkedToken, nil | |
| } | |
| // GetSystemDirectory retrieves the path to current location of the system | |
| // directory, which is typically, though not always, `C:\Windows\System32`. | |
| func GetSystemDirectory() (string, error) { | |
| n := uint32(MAX_PATH) | |
| for { | |
| b := make([]uint16, n) | |
| l, e := getSystemDirectory(&b[0], n) | |
| if e != nil { | |
| return "", e | |
| } | |
| if l <= n { | |
| return UTF16ToString(b[:l]), nil | |
| } | |
| n = l | |
| } | |
| } | |
| // GetWindowsDirectory retrieves the path to current location of the Windows | |
| // directory, which is typically, though not always, `C:\Windows`. This may | |
| // be a private user directory in the case that the application is running | |
| // under a terminal server. | |
| func GetWindowsDirectory() (string, error) { | |
| n := uint32(MAX_PATH) | |
| for { | |
| b := make([]uint16, n) | |
| l, e := getWindowsDirectory(&b[0], n) | |
| if e != nil { | |
| return "", e | |
| } | |
| if l <= n { | |
| return UTF16ToString(b[:l]), nil | |
| } | |
| n = l | |
| } | |
| } | |
| // GetSystemWindowsDirectory retrieves the path to current location of the | |
| // Windows directory, which is typically, though not always, `C:\Windows`. | |
| func GetSystemWindowsDirectory() (string, error) { | |
| n := uint32(MAX_PATH) | |
| for { | |
| b := make([]uint16, n) | |
| l, e := getSystemWindowsDirectory(&b[0], n) | |
| if e != nil { | |
| return "", e | |
| } | |
| if l <= n { | |
| return UTF16ToString(b[:l]), nil | |
| } | |
| n = l | |
| } | |
| } | |
| // IsMember reports whether the access token t is a member of the provided SID. | |
| func (t Token) IsMember(sid *SID) (bool, error) { | |
| var b int32 | |
| if e := checkTokenMembership(t, sid, &b); e != nil { | |
| return false, e | |
| } | |
| return b != 0, nil | |
| } | |
| // IsRestricted reports whether the access token t is a restricted token. | |
| func (t Token) IsRestricted() (isRestricted bool, err error) { | |
| isRestricted, err = isTokenRestricted(t) | |
| if !isRestricted && err == syscall.EINVAL { | |
| // If err is EINVAL, this returned ERROR_SUCCESS indicating a non-restricted token. | |
| err = nil | |
| } | |
| return | |
| } | |
| const ( | |
| WTS_CONSOLE_CONNECT = 0x1 | |
| WTS_CONSOLE_DISCONNECT = 0x2 | |
| WTS_REMOTE_CONNECT = 0x3 | |
| WTS_REMOTE_DISCONNECT = 0x4 | |
| WTS_SESSION_LOGON = 0x5 | |
| WTS_SESSION_LOGOFF = 0x6 | |
| WTS_SESSION_LOCK = 0x7 | |
| WTS_SESSION_UNLOCK = 0x8 | |
| WTS_SESSION_REMOTE_CONTROL = 0x9 | |
| WTS_SESSION_CREATE = 0xa | |
| WTS_SESSION_TERMINATE = 0xb | |
| ) | |
| const ( | |
| WTSActive = 0 | |
| WTSConnected = 1 | |
| WTSConnectQuery = 2 | |
| WTSShadow = 3 | |
| WTSDisconnected = 4 | |
| WTSIdle = 5 | |
| WTSListen = 6 | |
| WTSReset = 7 | |
| WTSDown = 8 | |
| WTSInit = 9 | |
| ) | |
| type WTSSESSION_NOTIFICATION struct { | |
| Size uint32 | |
| SessionID uint32 | |
| } | |
| type WTS_SESSION_INFO struct { | |
| SessionID uint32 | |
| WindowStationName *uint16 | |
| State uint32 | |
| } | |
| //sys WTSQueryUserToken(session uint32, token *Token) (err error) = wtsapi32.WTSQueryUserToken | |
| //sys WTSEnumerateSessions(handle Handle, reserved uint32, version uint32, sessions **WTS_SESSION_INFO, count *uint32) (err error) = wtsapi32.WTSEnumerateSessionsW | |
| //sys WTSFreeMemory(ptr uintptr) = wtsapi32.WTSFreeMemory | |
| //sys WTSGetActiveConsoleSessionId() (sessionID uint32) | |
| type ACL struct { | |
| aclRevision byte | |
| sbz1 byte | |
| aclSize uint16 | |
| AceCount uint16 | |
| sbz2 uint16 | |
| } | |
| type SECURITY_DESCRIPTOR struct { | |
| revision byte | |
| sbz1 byte | |
| control SECURITY_DESCRIPTOR_CONTROL | |
| owner *SID | |
| group *SID | |
| sacl *ACL | |
| dacl *ACL | |
| } | |
| type SECURITY_QUALITY_OF_SERVICE struct { | |
| Length uint32 | |
| ImpersonationLevel uint32 | |
| ContextTrackingMode byte | |
| EffectiveOnly byte | |
| } | |
| // Constants for the ContextTrackingMode field of SECURITY_QUALITY_OF_SERVICE. | |
| const ( | |
| SECURITY_STATIC_TRACKING = 0 | |
| SECURITY_DYNAMIC_TRACKING = 1 | |
| ) | |
| type SecurityAttributes struct { | |
| Length uint32 | |
| SecurityDescriptor *SECURITY_DESCRIPTOR | |
| InheritHandle uint32 | |
| } | |
| type SE_OBJECT_TYPE uint32 | |
| // Constants for type SE_OBJECT_TYPE | |
| const ( | |
| SE_UNKNOWN_OBJECT_TYPE = 0 | |
| SE_FILE_OBJECT = 1 | |
| SE_SERVICE = 2 | |
| SE_PRINTER = 3 | |
| SE_REGISTRY_KEY = 4 | |
| SE_LMSHARE = 5 | |
| SE_KERNEL_OBJECT = 6 | |
| SE_WINDOW_OBJECT = 7 | |
| SE_DS_OBJECT = 8 | |
| SE_DS_OBJECT_ALL = 9 | |
| SE_PROVIDER_DEFINED_OBJECT = 10 | |
| SE_WMIGUID_OBJECT = 11 | |
| SE_REGISTRY_WOW64_32KEY = 12 | |
| SE_REGISTRY_WOW64_64KEY = 13 | |
| ) | |
| type SECURITY_INFORMATION uint32 | |
| // Constants for type SECURITY_INFORMATION | |
| const ( | |
| OWNER_SECURITY_INFORMATION = 0x00000001 | |
| GROUP_SECURITY_INFORMATION = 0x00000002 | |
| DACL_SECURITY_INFORMATION = 0x00000004 | |
| SACL_SECURITY_INFORMATION = 0x00000008 | |
| LABEL_SECURITY_INFORMATION = 0x00000010 | |
| ATTRIBUTE_SECURITY_INFORMATION = 0x00000020 | |
| SCOPE_SECURITY_INFORMATION = 0x00000040 | |
| BACKUP_SECURITY_INFORMATION = 0x00010000 | |
| PROTECTED_DACL_SECURITY_INFORMATION = 0x80000000 | |
| PROTECTED_SACL_SECURITY_INFORMATION = 0x40000000 | |
| UNPROTECTED_DACL_SECURITY_INFORMATION = 0x20000000 | |
| UNPROTECTED_SACL_SECURITY_INFORMATION = 0x10000000 | |
| ) | |
| type SECURITY_DESCRIPTOR_CONTROL uint16 | |
| // Constants for type SECURITY_DESCRIPTOR_CONTROL | |
| const ( | |
| SE_OWNER_DEFAULTED = 0x0001 | |
| SE_GROUP_DEFAULTED = 0x0002 | |
| SE_DACL_PRESENT = 0x0004 | |
| SE_DACL_DEFAULTED = 0x0008 | |
| SE_SACL_PRESENT = 0x0010 | |
| SE_SACL_DEFAULTED = 0x0020 | |
| SE_DACL_AUTO_INHERIT_REQ = 0x0100 | |
| SE_SACL_AUTO_INHERIT_REQ = 0x0200 | |
| SE_DACL_AUTO_INHERITED = 0x0400 | |
| SE_SACL_AUTO_INHERITED = 0x0800 | |
| SE_DACL_PROTECTED = 0x1000 | |
| SE_SACL_PROTECTED = 0x2000 | |
| SE_RM_CONTROL_VALID = 0x4000 | |
| SE_SELF_RELATIVE = 0x8000 | |
| ) | |
| type ACCESS_MASK uint32 | |
| // Constants for type ACCESS_MASK | |
| const ( | |
| DELETE = 0x00010000 | |
| READ_CONTROL = 0x00020000 | |
| WRITE_DAC = 0x00040000 | |
| WRITE_OWNER = 0x00080000 | |
| SYNCHRONIZE = 0x00100000 | |
| STANDARD_RIGHTS_REQUIRED = 0x000F0000 | |
| STANDARD_RIGHTS_READ = READ_CONTROL | |
| STANDARD_RIGHTS_WRITE = READ_CONTROL | |
| STANDARD_RIGHTS_EXECUTE = READ_CONTROL | |
| STANDARD_RIGHTS_ALL = 0x001F0000 | |
| SPECIFIC_RIGHTS_ALL = 0x0000FFFF | |
| ACCESS_SYSTEM_SECURITY = 0x01000000 | |
| MAXIMUM_ALLOWED = 0x02000000 | |
| GENERIC_READ = 0x80000000 | |
| GENERIC_WRITE = 0x40000000 | |
| GENERIC_EXECUTE = 0x20000000 | |
| GENERIC_ALL = 0x10000000 | |
| ) | |
| type ACCESS_MODE uint32 | |
| // Constants for type ACCESS_MODE | |
| const ( | |
| NOT_USED_ACCESS = 0 | |
| GRANT_ACCESS = 1 | |
| SET_ACCESS = 2 | |
| DENY_ACCESS = 3 | |
| REVOKE_ACCESS = 4 | |
| SET_AUDIT_SUCCESS = 5 | |
| SET_AUDIT_FAILURE = 6 | |
| ) | |
| // Constants for AceFlags and Inheritance fields | |
| const ( | |
| NO_INHERITANCE = 0x0 | |
| SUB_OBJECTS_ONLY_INHERIT = 0x1 | |
| SUB_CONTAINERS_ONLY_INHERIT = 0x2 | |
| SUB_CONTAINERS_AND_OBJECTS_INHERIT = 0x3 | |
| INHERIT_NO_PROPAGATE = 0x4 | |
| INHERIT_ONLY = 0x8 | |
| INHERITED_ACCESS_ENTRY = 0x10 | |
| INHERITED_PARENT = 0x10000000 | |
| INHERITED_GRANDPARENT = 0x20000000 | |
| OBJECT_INHERIT_ACE = 0x1 | |
| CONTAINER_INHERIT_ACE = 0x2 | |
| NO_PROPAGATE_INHERIT_ACE = 0x4 | |
| INHERIT_ONLY_ACE = 0x8 | |
| INHERITED_ACE = 0x10 | |
| VALID_INHERIT_FLAGS = 0x1F | |
| ) | |
| type MULTIPLE_TRUSTEE_OPERATION uint32 | |
| // Constants for MULTIPLE_TRUSTEE_OPERATION | |
| const ( | |
| NO_MULTIPLE_TRUSTEE = 0 | |
| TRUSTEE_IS_IMPERSONATE = 1 | |
| ) | |
| type TRUSTEE_FORM uint32 | |
| // Constants for TRUSTEE_FORM | |
| const ( | |
| TRUSTEE_IS_SID = 0 | |
| TRUSTEE_IS_NAME = 1 | |
| TRUSTEE_BAD_FORM = 2 | |
| TRUSTEE_IS_OBJECTS_AND_SID = 3 | |
| TRUSTEE_IS_OBJECTS_AND_NAME = 4 | |
| ) | |
| type TRUSTEE_TYPE uint32 | |
| // Constants for TRUSTEE_TYPE | |
| const ( | |
| TRUSTEE_IS_UNKNOWN = 0 | |
| TRUSTEE_IS_USER = 1 | |
| TRUSTEE_IS_GROUP = 2 | |
| TRUSTEE_IS_DOMAIN = 3 | |
| TRUSTEE_IS_ALIAS = 4 | |
| TRUSTEE_IS_WELL_KNOWN_GROUP = 5 | |
| TRUSTEE_IS_DELETED = 6 | |
| TRUSTEE_IS_INVALID = 7 | |
| TRUSTEE_IS_COMPUTER = 8 | |
| ) | |
| // Constants for ObjectsPresent field | |
| const ( | |
| ACE_OBJECT_TYPE_PRESENT = 0x1 | |
| ACE_INHERITED_OBJECT_TYPE_PRESENT = 0x2 | |
| ) | |
| type EXPLICIT_ACCESS struct { | |
| AccessPermissions ACCESS_MASK | |
| AccessMode ACCESS_MODE | |
| Inheritance uint32 | |
| Trustee TRUSTEE | |
| } | |
| // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header | |
| type ACE_HEADER struct { | |
| AceType uint8 | |
| AceFlags uint8 | |
| AceSize uint16 | |
| } | |
| // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-access_allowed_ace | |
| type ACCESS_ALLOWED_ACE struct { | |
| Header ACE_HEADER | |
| Mask ACCESS_MASK | |
| SidStart uint32 | |
| } | |
| const ( | |
| // Constants for AceType | |
| // https://learn.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-ace_header | |
| ACCESS_ALLOWED_ACE_TYPE = 0 | |
| ACCESS_DENIED_ACE_TYPE = 1 | |
| ) | |
| // This type is the union inside of TRUSTEE and must be created using one of the TrusteeValueFrom* functions. | |
| // | |
| // Go pointers stored in a TrusteeValue must be pinned using [runtime.Pinner] | |
| // for the lifetime of the TrusteeValue. | |
| type TrusteeValue uintptr | |
| // TrusteeValueFromString is unsafe and should not be used. | |
| // | |
| // It returns a uintptr containing a reference to newly-allocated memory | |
| // which will be freed by the garbage collector. | |
| // There is no way for the caller to safely reference this memory. | |
| // | |
| // To create a [TrusteeValue] from a string, use: | |
| // | |
| // p, err := windows.UTF16PtrFromString(s) | |
| // if err != nil { | |
| // // handle error | |
| // } | |
| // | |
| // // Pin the string for as long as it is used. | |
| // var pinner runtime.Pinner | |
| // pinner.Pin(p) | |
| // defer pinner.Unpin() | |
| // | |
| // tv := TrusteeValue(unsafe.Pointer(p)) | |
| // | |
| // Deprecated: TrusteeValueFromString is unsafe and should not be used. | |
| func TrusteeValueFromString(str string) TrusteeValue { | |
| return TrusteeValue(unsafe.Pointer(StringToUTF16Ptr(str))) | |
| } | |
| // TrusteeValueFromSID returns a [TrusteeValue] referencing sid. | |
| // | |
| // The caller must pin sid using a [runtime.Pinner] for the lifetime of the TrusteeValue. | |
| func TrusteeValueFromSID(sid *SID) TrusteeValue { | |
| return TrusteeValue(unsafe.Pointer(sid)) | |
| } | |
| // TrusteeValueFromObjectsAndSid returns a [TrusteeValue] referencing objectsAndSid. | |
| // | |
| // The caller must pin objectsAndSid using a [runtime.Pinner] for the lifetime of the TrusteeValue. | |
| func TrusteeValueFromObjectsAndSid(objectsAndSid *OBJECTS_AND_SID) TrusteeValue { | |
| return TrusteeValue(unsafe.Pointer(objectsAndSid)) | |
| } | |
| // TrusteeValueFromObjectsAndName returns a [TrusteeValue] referencing objectsAndName. | |
| // | |
| // The caller must pin objectsAndName using a [runtime.Pinner] for the lifetime of the TrusteeValue. | |
| func TrusteeValueFromObjectsAndName(objectsAndName *OBJECTS_AND_NAME) TrusteeValue { | |
| return TrusteeValue(unsafe.Pointer(objectsAndName)) | |
| } | |
| type TRUSTEE struct { | |
| MultipleTrustee *TRUSTEE | |
| MultipleTrusteeOperation MULTIPLE_TRUSTEE_OPERATION | |
| TrusteeForm TRUSTEE_FORM | |
| TrusteeType TRUSTEE_TYPE | |
| TrusteeValue TrusteeValue | |
| } | |
| type OBJECTS_AND_SID struct { | |
| ObjectsPresent uint32 | |
| ObjectTypeGuid GUID | |
| InheritedObjectTypeGuid GUID | |
| Sid *SID | |
| } | |
| type OBJECTS_AND_NAME struct { | |
| ObjectsPresent uint32 | |
| ObjectType SE_OBJECT_TYPE | |
| ObjectTypeName *uint16 | |
| InheritedObjectTypeName *uint16 | |
| Name *uint16 | |
| } | |
| //sys getSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) = advapi32.GetSecurityInfo | |
| //sys SetSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) = advapi32.SetSecurityInfo | |
| //sys getNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner **SID, group **SID, dacl **ACL, sacl **ACL, sd **SECURITY_DESCRIPTOR) (ret error) = advapi32.GetNamedSecurityInfoW | |
| //sys SetNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION, owner *SID, group *SID, dacl *ACL, sacl *ACL) (ret error) = advapi32.SetNamedSecurityInfoW | |
| //sys SetKernelObjectSecurity(handle Handle, securityInformation SECURITY_INFORMATION, securityDescriptor *SECURITY_DESCRIPTOR) (err error) = advapi32.SetKernelObjectSecurity | |
| //sys buildSecurityDescriptor(owner *TRUSTEE, group *TRUSTEE, countAccessEntries uint32, accessEntries *EXPLICIT_ACCESS, countAuditEntries uint32, auditEntries *EXPLICIT_ACCESS, oldSecurityDescriptor *SECURITY_DESCRIPTOR, sizeNewSecurityDescriptor *uint32, newSecurityDescriptor **SECURITY_DESCRIPTOR) (ret error) = advapi32.BuildSecurityDescriptorW | |
| //sys initializeSecurityDescriptor(absoluteSD *SECURITY_DESCRIPTOR, revision uint32) (err error) = advapi32.InitializeSecurityDescriptor | |
| //sys getSecurityDescriptorControl(sd *SECURITY_DESCRIPTOR, control *SECURITY_DESCRIPTOR_CONTROL, revision *uint32) (err error) = advapi32.GetSecurityDescriptorControl | |
| //sys getSecurityDescriptorDacl(sd *SECURITY_DESCRIPTOR, daclPresent *bool, dacl **ACL, daclDefaulted *bool) (err error) = advapi32.GetSecurityDescriptorDacl | |
| //sys getSecurityDescriptorSacl(sd *SECURITY_DESCRIPTOR, saclPresent *bool, sacl **ACL, saclDefaulted *bool) (err error) = advapi32.GetSecurityDescriptorSacl | |
| //sys getSecurityDescriptorOwner(sd *SECURITY_DESCRIPTOR, owner **SID, ownerDefaulted *bool) (err error) = advapi32.GetSecurityDescriptorOwner | |
| //sys getSecurityDescriptorGroup(sd *SECURITY_DESCRIPTOR, group **SID, groupDefaulted *bool) (err error) = advapi32.GetSecurityDescriptorGroup | |
| //sys getSecurityDescriptorLength(sd *SECURITY_DESCRIPTOR) (len uint32) = advapi32.GetSecurityDescriptorLength | |
| //sys getSecurityDescriptorRMControl(sd *SECURITY_DESCRIPTOR, rmControl *uint8) (ret error) [failretval!=0] = advapi32.GetSecurityDescriptorRMControl | |
| //sys isValidSecurityDescriptor(sd *SECURITY_DESCRIPTOR) (isValid bool) = advapi32.IsValidSecurityDescriptor | |
| //sys setSecurityDescriptorControl(sd *SECURITY_DESCRIPTOR, controlBitsOfInterest SECURITY_DESCRIPTOR_CONTROL, controlBitsToSet SECURITY_DESCRIPTOR_CONTROL) (err error) = advapi32.SetSecurityDescriptorControl | |
| //sys setSecurityDescriptorDacl(sd *SECURITY_DESCRIPTOR, daclPresent bool, dacl *ACL, daclDefaulted bool) (err error) = advapi32.SetSecurityDescriptorDacl | |
| //sys setSecurityDescriptorSacl(sd *SECURITY_DESCRIPTOR, saclPresent bool, sacl *ACL, saclDefaulted bool) (err error) = advapi32.SetSecurityDescriptorSacl | |
| //sys setSecurityDescriptorOwner(sd *SECURITY_DESCRIPTOR, owner *SID, ownerDefaulted bool) (err error) = advapi32.SetSecurityDescriptorOwner | |
| //sys setSecurityDescriptorGroup(sd *SECURITY_DESCRIPTOR, group *SID, groupDefaulted bool) (err error) = advapi32.SetSecurityDescriptorGroup | |
| //sys setSecurityDescriptorRMControl(sd *SECURITY_DESCRIPTOR, rmControl *uint8) = advapi32.SetSecurityDescriptorRMControl | |
| //sys convertStringSecurityDescriptorToSecurityDescriptor(str string, revision uint32, sd **SECURITY_DESCRIPTOR, size *uint32) (err error) = advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW | |
| //sys convertSecurityDescriptorToStringSecurityDescriptor(sd *SECURITY_DESCRIPTOR, revision uint32, securityInformation SECURITY_INFORMATION, str **uint16, strLen *uint32) (err error) = advapi32.ConvertSecurityDescriptorToStringSecurityDescriptorW | |
| //sys makeAbsoluteSD(selfRelativeSD *SECURITY_DESCRIPTOR, absoluteSD *SECURITY_DESCRIPTOR, absoluteSDSize *uint32, dacl *ACL, daclSize *uint32, sacl *ACL, saclSize *uint32, owner *SID, ownerSize *uint32, group *SID, groupSize *uint32) (err error) = advapi32.MakeAbsoluteSD | |
| //sys makeSelfRelativeSD(absoluteSD *SECURITY_DESCRIPTOR, selfRelativeSD *SECURITY_DESCRIPTOR, selfRelativeSDSize *uint32) (err error) = advapi32.MakeSelfRelativeSD | |
| //sys setEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) = advapi32.SetEntriesInAclW | |
| //sys GetAce(acl *ACL, aceIndex uint32, pAce **ACCESS_ALLOWED_ACE) (err error) = advapi32.GetAce | |
| // Control returns the security descriptor control bits. | |
| func (sd *SECURITY_DESCRIPTOR) Control() (control SECURITY_DESCRIPTOR_CONTROL, revision uint32, err error) { | |
| err = getSecurityDescriptorControl(sd, &control, &revision) | |
| return | |
| } | |
| // SetControl sets the security descriptor control bits. | |
| func (sd *SECURITY_DESCRIPTOR) SetControl(controlBitsOfInterest SECURITY_DESCRIPTOR_CONTROL, controlBitsToSet SECURITY_DESCRIPTOR_CONTROL) error { | |
| return setSecurityDescriptorControl(sd, controlBitsOfInterest, controlBitsToSet) | |
| } | |
| // RMControl returns the security descriptor resource manager control bits. | |
| func (sd *SECURITY_DESCRIPTOR) RMControl() (control uint8, err error) { | |
| err = getSecurityDescriptorRMControl(sd, &control) | |
| return | |
| } | |
| // SetRMControl sets the security descriptor resource manager control bits. | |
| func (sd *SECURITY_DESCRIPTOR) SetRMControl(rmControl uint8) { | |
| setSecurityDescriptorRMControl(sd, &rmControl) | |
| } | |
| // DACL returns the security descriptor DACL and whether it was defaulted. The dacl return value may be nil | |
| // if a DACL exists but is an "empty DACL", meaning fully permissive. If the DACL does not exist, err returns | |
| // ERROR_OBJECT_NOT_FOUND. | |
| func (sd *SECURITY_DESCRIPTOR) DACL() (dacl *ACL, defaulted bool, err error) { | |
| var present bool | |
| err = getSecurityDescriptorDacl(sd, &present, &dacl, &defaulted) | |
| if !present { | |
| err = ERROR_OBJECT_NOT_FOUND | |
| } | |
| return | |
| } | |
| // SetDACL sets the absolute security descriptor DACL. | |
| func (absoluteSD *SECURITY_DESCRIPTOR) SetDACL(dacl *ACL, present, defaulted bool) error { | |
| return setSecurityDescriptorDacl(absoluteSD, present, dacl, defaulted) | |
| } | |
| // SACL returns the security descriptor SACL and whether it was defaulted. The sacl return value may be nil | |
| // if a SACL exists but is an "empty SACL", meaning fully permissive. If the SACL does not exist, err returns | |
| // ERROR_OBJECT_NOT_FOUND. | |
| func (sd *SECURITY_DESCRIPTOR) SACL() (sacl *ACL, defaulted bool, err error) { | |
| var present bool | |
| err = getSecurityDescriptorSacl(sd, &present, &sacl, &defaulted) | |
| if !present { | |
| err = ERROR_OBJECT_NOT_FOUND | |
| } | |
| return | |
| } | |
| // SetSACL sets the absolute security descriptor SACL. | |
| func (absoluteSD *SECURITY_DESCRIPTOR) SetSACL(sacl *ACL, present, defaulted bool) error { | |
| return setSecurityDescriptorSacl(absoluteSD, present, sacl, defaulted) | |
| } | |
| // Owner returns the security descriptor owner and whether it was defaulted. | |
| func (sd *SECURITY_DESCRIPTOR) Owner() (owner *SID, defaulted bool, err error) { | |
| err = getSecurityDescriptorOwner(sd, &owner, &defaulted) | |
| return | |
| } | |
| // SetOwner sets the absolute security descriptor owner. | |
| func (absoluteSD *SECURITY_DESCRIPTOR) SetOwner(owner *SID, defaulted bool) error { | |
| return setSecurityDescriptorOwner(absoluteSD, owner, defaulted) | |
| } | |
| // Group returns the security descriptor group and whether it was defaulted. | |
| func (sd *SECURITY_DESCRIPTOR) Group() (group *SID, defaulted bool, err error) { | |
| err = getSecurityDescriptorGroup(sd, &group, &defaulted) | |
| return | |
| } | |
| // SetGroup sets the absolute security descriptor owner. | |
| func (absoluteSD *SECURITY_DESCRIPTOR) SetGroup(group *SID, defaulted bool) error { | |
| return setSecurityDescriptorGroup(absoluteSD, group, defaulted) | |
| } | |
| // Length returns the length of the security descriptor. | |
| func (sd *SECURITY_DESCRIPTOR) Length() uint32 { | |
| return getSecurityDescriptorLength(sd) | |
| } | |
| // IsValid returns whether the security descriptor is valid. | |
| func (sd *SECURITY_DESCRIPTOR) IsValid() bool { | |
| return isValidSecurityDescriptor(sd) | |
| } | |
| // String returns the SDDL form of the security descriptor, with a function signature that can be | |
| // used with %v formatting directives. | |
| func (sd *SECURITY_DESCRIPTOR) String() string { | |
| var sddl *uint16 | |
| err := convertSecurityDescriptorToStringSecurityDescriptor(sd, 1, 0xff, &sddl, nil) | |
| if err != nil { | |
| return "" | |
| } | |
| defer LocalFree(Handle(unsafe.Pointer(sddl))) | |
| return UTF16PtrToString(sddl) | |
| } | |
| // ToAbsolute converts a self-relative security descriptor into an absolute one. | |
| func (selfRelativeSD *SECURITY_DESCRIPTOR) ToAbsolute() (absoluteSD *SECURITY_DESCRIPTOR, err error) { | |
| control, _, err := selfRelativeSD.Control() | |
| if err != nil { | |
| return | |
| } | |
| if control&SE_SELF_RELATIVE == 0 { | |
| err = ERROR_INVALID_PARAMETER | |
| return | |
| } | |
| var absoluteSDSize, daclSize, saclSize, ownerSize, groupSize uint32 | |
| err = makeAbsoluteSD(selfRelativeSD, nil, &absoluteSDSize, | |
| nil, &daclSize, nil, &saclSize, nil, &ownerSize, nil, &groupSize) | |
| switch err { | |
| case ERROR_INSUFFICIENT_BUFFER: | |
| case nil: | |
| // makeAbsoluteSD is expected to fail, but it succeeds. | |
| return nil, ERROR_INTERNAL_ERROR | |
| default: | |
| return nil, err | |
| } | |
| if absoluteSDSize > 0 { | |
| absoluteSD = new(SECURITY_DESCRIPTOR) | |
| if unsafe.Sizeof(*absoluteSD) < uintptr(absoluteSDSize) { | |
| panic("sizeof(SECURITY_DESCRIPTOR) too small") | |
| } | |
| } | |
| var ( | |
| dacl *ACL | |
| sacl *ACL | |
| owner *SID | |
| group *SID | |
| ) | |
| if daclSize > 0 { | |
| dacl = (*ACL)(unsafe.Pointer(unsafe.SliceData(make([]byte, daclSize)))) | |
| } | |
| if saclSize > 0 { | |
| sacl = (*ACL)(unsafe.Pointer(unsafe.SliceData(make([]byte, saclSize)))) | |
| } | |
| if ownerSize > 0 { | |
| owner = (*SID)(unsafe.Pointer(unsafe.SliceData(make([]byte, ownerSize)))) | |
| } | |
| if groupSize > 0 { | |
| group = (*SID)(unsafe.Pointer(unsafe.SliceData(make([]byte, groupSize)))) | |
| } | |
| // We call into Windows via makeAbsoluteSD, which sets up | |
| // pointers within absoluteSD that point to other chunks of memory | |
| // we pass into makeAbsoluteSD, and that happens outside the view of the GC. | |
| // We therefore take some care here to then verify the pointers are as we expect | |
| // and set them explicitly in view of the GC. See https://go.dev/issue/73199. | |
| // TODO: consider weak pointers once Go 1.24 is appropriate. See suggestion in https://go.dev/cl/663575. | |
| err = makeAbsoluteSD(selfRelativeSD, absoluteSD, &absoluteSDSize, | |
| dacl, &daclSize, sacl, &saclSize, owner, &ownerSize, group, &groupSize) | |
| if err != nil { | |
| // Don't return absoluteSD, which might be partially initialized. | |
| return nil, err | |
| } | |
| // Before using any fields, verify absoluteSD is in the format we expect according to Windows. | |
| // See https://learn.microsoft.com/en-us/windows/win32/secauthz/absolute-and-self-relative-security-descriptors | |
| absControl, _, err := absoluteSD.Control() | |
| if err != nil { | |
| panic("absoluteSD: " + err.Error()) | |
| } | |
| if absControl&SE_SELF_RELATIVE != 0 { | |
| panic("absoluteSD not in absolute format") | |
| } | |
| if absoluteSD.dacl != dacl { | |
| panic("dacl pointer mismatch") | |
| } | |
| if absoluteSD.sacl != sacl { | |
| panic("sacl pointer mismatch") | |
| } | |
| if absoluteSD.owner != owner { | |
| panic("owner pointer mismatch") | |
| } | |
| if absoluteSD.group != group { | |
| panic("group pointer mismatch") | |
| } | |
| absoluteSD.dacl = dacl | |
| absoluteSD.sacl = sacl | |
| absoluteSD.owner = owner | |
| absoluteSD.group = group | |
| return | |
| } | |
| // ToSelfRelative converts an absolute security descriptor into a self-relative one. | |
| func (absoluteSD *SECURITY_DESCRIPTOR) ToSelfRelative() (selfRelativeSD *SECURITY_DESCRIPTOR, err error) { | |
| control, _, err := absoluteSD.Control() | |
| if err != nil { | |
| return | |
| } | |
| if control&SE_SELF_RELATIVE != 0 { | |
| err = ERROR_INVALID_PARAMETER | |
| return | |
| } | |
| var selfRelativeSDSize uint32 | |
| err = makeSelfRelativeSD(absoluteSD, nil, &selfRelativeSDSize) | |
| switch err { | |
| case ERROR_INSUFFICIENT_BUFFER: | |
| case nil: | |
| // makeSelfRelativeSD is expected to fail, but it succeeds. | |
| return nil, ERROR_INTERNAL_ERROR | |
| default: | |
| return nil, err | |
| } | |
| if selfRelativeSDSize > 0 { | |
| selfRelativeSD = (*SECURITY_DESCRIPTOR)(unsafe.Pointer(&make([]byte, selfRelativeSDSize)[0])) | |
| } | |
| err = makeSelfRelativeSD(absoluteSD, selfRelativeSD, &selfRelativeSDSize) | |
| return | |
| } | |
| func (selfRelativeSD *SECURITY_DESCRIPTOR) copySelfRelativeSecurityDescriptor() *SECURITY_DESCRIPTOR { | |
| sdLen := int(selfRelativeSD.Length()) | |
| const min = int(unsafe.Sizeof(SECURITY_DESCRIPTOR{})) | |
| if sdLen < min { | |
| sdLen = min | |
| } | |
| src := unsafe.Slice((*byte)(unsafe.Pointer(selfRelativeSD)), sdLen) | |
| // SECURITY_DESCRIPTOR has pointers in it, which means checkptr expects for it to | |
| // be aligned properly. When we're copying a Windows-allocated struct to a | |
| // Go-allocated one, make sure that the Go allocation is aligned to the | |
| // pointer size. | |
| const psize = int(unsafe.Sizeof(uintptr(0))) | |
| alloc := make([]uintptr, (sdLen+psize-1)/psize) | |
| dst := unsafe.Slice((*byte)(unsafe.Pointer(&alloc[0])), sdLen) | |
| copy(dst, src) | |
| return (*SECURITY_DESCRIPTOR)(unsafe.Pointer(&dst[0])) | |
| } | |
| // SecurityDescriptorFromString converts an SDDL string describing a security descriptor into a | |
| // self-relative security descriptor object allocated on the Go heap. | |
| func SecurityDescriptorFromString(sddl string) (sd *SECURITY_DESCRIPTOR, err error) { | |
| var winHeapSD *SECURITY_DESCRIPTOR | |
| err = convertStringSecurityDescriptorToSecurityDescriptor(sddl, 1, &winHeapSD, nil) | |
| if err != nil { | |
| return | |
| } | |
| defer LocalFree(Handle(unsafe.Pointer(winHeapSD))) | |
| return winHeapSD.copySelfRelativeSecurityDescriptor(), nil | |
| } | |
| // GetSecurityInfo queries the security information for a given handle and returns the self-relative security | |
| // descriptor result on the Go heap. | |
| func GetSecurityInfo(handle Handle, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION) (sd *SECURITY_DESCRIPTOR, err error) { | |
| var winHeapSD *SECURITY_DESCRIPTOR | |
| err = getSecurityInfo(handle, objectType, securityInformation, nil, nil, nil, nil, &winHeapSD) | |
| if err != nil { | |
| return | |
| } | |
| defer LocalFree(Handle(unsafe.Pointer(winHeapSD))) | |
| return winHeapSD.copySelfRelativeSecurityDescriptor(), nil | |
| } | |
| // GetNamedSecurityInfo queries the security information for a given named object and returns the self-relative security | |
| // descriptor result on the Go heap. The security descriptor might be nil, even when err is nil, if the object exists | |
| // but has no security descriptor. | |
| func GetNamedSecurityInfo(objectName string, objectType SE_OBJECT_TYPE, securityInformation SECURITY_INFORMATION) (sd *SECURITY_DESCRIPTOR, err error) { | |
| var winHeapSD *SECURITY_DESCRIPTOR | |
| err = getNamedSecurityInfo(objectName, objectType, securityInformation, nil, nil, nil, nil, &winHeapSD) | |
| if err != nil { | |
| return | |
| } | |
| if winHeapSD == nil { | |
| return nil, nil | |
| } | |
| defer LocalFree(Handle(unsafe.Pointer(winHeapSD))) | |
| return winHeapSD.copySelfRelativeSecurityDescriptor(), nil | |
| } | |
| // BuildSecurityDescriptor makes a new security descriptor using the input trustees, explicit access lists, and | |
| // prior security descriptor to be merged, any of which can be nil, returning the self-relative security descriptor | |
| // result on the Go heap. | |
| func BuildSecurityDescriptor(owner *TRUSTEE, group *TRUSTEE, accessEntries []EXPLICIT_ACCESS, auditEntries []EXPLICIT_ACCESS, mergedSecurityDescriptor *SECURITY_DESCRIPTOR) (sd *SECURITY_DESCRIPTOR, err error) { | |
| var winHeapSD *SECURITY_DESCRIPTOR | |
| var winHeapSDSize uint32 | |
| var firstAccessEntry *EXPLICIT_ACCESS | |
| if len(accessEntries) > 0 { | |
| firstAccessEntry = &accessEntries[0] | |
| } | |
| var firstAuditEntry *EXPLICIT_ACCESS | |
| if len(auditEntries) > 0 { | |
| firstAuditEntry = &auditEntries[0] | |
| } | |
| err = buildSecurityDescriptor(owner, group, uint32(len(accessEntries)), firstAccessEntry, uint32(len(auditEntries)), firstAuditEntry, mergedSecurityDescriptor, &winHeapSDSize, &winHeapSD) | |
| if err != nil { | |
| return | |
| } | |
| defer LocalFree(Handle(unsafe.Pointer(winHeapSD))) | |
| return winHeapSD.copySelfRelativeSecurityDescriptor(), nil | |
| } | |
| // NewSecurityDescriptor creates and initializes a new absolute security descriptor. | |
| func NewSecurityDescriptor() (absoluteSD *SECURITY_DESCRIPTOR, err error) { | |
| absoluteSD = &SECURITY_DESCRIPTOR{} | |
| err = initializeSecurityDescriptor(absoluteSD, 1) | |
| return | |
| } | |
| // ACLFromEntries returns a new ACL on the Go heap containing a list of explicit entries as well as those of another ACL. | |
| // Both explicitEntries and mergedACL are optional and can be nil. | |
| func ACLFromEntries(explicitEntries []EXPLICIT_ACCESS, mergedACL *ACL) (acl *ACL, err error) { | |
| var firstExplicitEntry *EXPLICIT_ACCESS | |
| if len(explicitEntries) > 0 { | |
| firstExplicitEntry = &explicitEntries[0] | |
| } | |
| var winHeapACL *ACL | |
| err = setEntriesInAcl(uint32(len(explicitEntries)), firstExplicitEntry, mergedACL, &winHeapACL) | |
| if err != nil { | |
| return | |
| } | |
| defer LocalFree(Handle(unsafe.Pointer(winHeapACL))) | |
| aclBytes := make([]byte, winHeapACL.aclSize) | |
| copy(aclBytes, (*[(1 << 31) - 1]byte)(unsafe.Pointer(winHeapACL))[:len(aclBytes):len(aclBytes)]) | |
| return (*ACL)(unsafe.Pointer(&aclBytes[0])), nil | |
| } |