mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-11-24 04:36:38 +00:00
49009fbd8f
This fixes some linkname shenanigans previous versions of the library were using. It's now safe to upgrade to Go 1.23 and beyond once they become available.
1459 lines
53 KiB
Go
1459 lines
53 KiB
Go
// 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.
|
|
type TrusteeValue uintptr
|
|
|
|
func TrusteeValueFromString(str string) TrusteeValue {
|
|
return TrusteeValue(unsafe.Pointer(StringToUTF16Ptr(str)))
|
|
}
|
|
func TrusteeValueFromSID(sid *SID) TrusteeValue {
|
|
return TrusteeValue(unsafe.Pointer(sid))
|
|
}
|
|
func TrusteeValueFromObjectsAndSid(objectsAndSid *OBJECTS_AND_SID) TrusteeValue {
|
|
return TrusteeValue(unsafe.Pointer(objectsAndSid))
|
|
}
|
|
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) (ret 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 = (*SECURITY_DESCRIPTOR)(unsafe.Pointer(&make([]byte, absoluteSDSize)[0]))
|
|
}
|
|
var (
|
|
dacl *ACL
|
|
sacl *ACL
|
|
owner *SID
|
|
group *SID
|
|
)
|
|
if daclSize > 0 {
|
|
dacl = (*ACL)(unsafe.Pointer(&make([]byte, daclSize)[0]))
|
|
}
|
|
if saclSize > 0 {
|
|
sacl = (*ACL)(unsafe.Pointer(&make([]byte, saclSize)[0]))
|
|
}
|
|
if ownerSize > 0 {
|
|
owner = (*SID)(unsafe.Pointer(&make([]byte, ownerSize)[0]))
|
|
}
|
|
if groupSize > 0 {
|
|
group = (*SID)(unsafe.Pointer(&make([]byte, groupSize)[0]))
|
|
}
|
|
err = makeAbsoluteSD(selfRelativeSD, absoluteSD, &absoluteSDSize,
|
|
dacl, &daclSize, sacl, &saclSize, owner, &ownerSize, group, &groupSize)
|
|
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.
|
|
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
|
|
}
|
|
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
|
|
}
|