// FUNCTION: SetPrinterDACL
//
// PURPOSE: Applies DACL to specified printer
//
// RETURN VALUE: true or false
//
// COMMENTS:
static bool SetPrinterDACL(string szPrinterName, PACL pDacl)
{
var PrnDefs = new PRINTER_DEFAULTS
{
DesiredAccess = ACCESS_MASK.READ_CONTROL | ACCESS_MASK.WRITE_DAC
};
if (!OpenPrinter(szPrinterName, out var hPrinter, PrnDefs))
{
return(false);
}
using (hPrinter)
{
var NewSD = new SafePSECURITY_DESCRIPTOR();
if (!SetSecurityDescriptorDacl(NewSD, true, pDacl, false))
{
return(false);
}
if (!SetPrinter(hPrinter, new PRINTER_INFO_3 {
pSecurityDescriptor = NewSD
}))
{
return(false);
}
}
return(true);
}
public void QuerySetServiceObjectSecurityTest()
{
using (var pSD = new SafePSECURITY_DESCRIPTOR(1024))
{
Assert.That(QueryServiceObjectSecurity(hSvc, SECURITY_INFORMATION.DACL_SECURITY_INFORMATION, pSD, pSD.Size, out var req), ResultIs.Successful);
Assert.That(SetServiceObjectSecurity(hSvc, SECURITY_INFORMATION.DACL_SECURITY_INFORMATION, pSD), ResultIs.Successful);
}
}
public void AuthzAccessCheckAndCachedTest()
{
using SafeAUTHZ_RESOURCE_MANAGER_HANDLE hRM = GetAuthzInitializeResourceManager();
using SafeAUTHZ_CLIENT_CONTEXT_HANDLE hCtx = GetCurrentUserAuthContext(hRM);
using SafeAUTHZ_AUDIT_EVENT_HANDLE hEvt = GetAuthzInitializeObjectAccessAuditEvent();
using SafePSECURITY_DESCRIPTOR psd = AdvApi32Tests.GetSD(TestCaseSources.SmallFile);
using AUTHZ_ACCESS_REPLY reply = new(1);
AUTHZ_ACCESS_REQUEST req = new(ACCESS_MASK.MAXIMUM_ALLOWED);
Assert.That(AuthzAccessCheck(AuthzAccessCheckFlags.NONE, hCtx, req, hEvt, psd, null, 0, reply, out SafeAUTHZ_ACCESS_CHECK_RESULTS_HANDLE hRes), ResultIs.Successful);
Assert.That(reply.GrantedAccessMask, Is.Not.EqualTo(IntPtr.Zero));
TestContext.WriteLine($"Access:{string.Join(",", reply.GrantedAccessMaskValues.Select(u => ((FileAccess)u).ToString()))}");
Assert.That(AuthzCachedAccessCheck(0, hRes, req, default, reply), Is.True);
public void BuildSecurityDescriptorTest()
{
SafePSECURITY_DESCRIPTOR pSd = null;
Assert.That(() =>
{
BuildTrusteeWithName(out var trustee, userName);
BuildTrusteeWithName(out var grpTrustee, localAdmins);
BuildExplicitAccessWithName(out var ea, userName, 0x10000000, ACCESS_MODE.SET_ACCESS, INHERIT_FLAGS.SUB_CONTAINERS_AND_OBJECTS_INHERIT);
BuildSecurityDescriptor(trustee, grpTrustee, 1, new[] { ea }, 0, null, PSECURITY_DESCRIPTOR.NULL, out var sz, out pSd);
}, Throws.Nothing);
Assert.That(pSd, Is.Not.Null);
Assert.That(pSd.IsInvalid, Is.False);
pSd.Dispose();
}
public void EventAccessTest()
{
var etp = EVENT_TRACE_PROPERTIES.Create(Guid.NewGuid());
etp.LogFileMode = LogFileMode.EVENT_TRACE_FILE_MODE_SEQUENTIAL;
etp.MaximumFileSize = 1;
etp.LogFileName = logfilePath;
etp.LoggerName = "MySession";
var sess = new EventTraceSession(etp);
var sz = 1024U;
using var sd = new SafePSECURITY_DESCRIPTOR((int)sz);
Assert.That(EventAccessQuery(sess.ProviderGuid, sd, ref sz), ResultIs.Successful);
Assert.That(EventAccessControl(sess.ProviderGuid, EVENTSECURITYOPERATION.EventSecurityAddDACL, SafePSID.Current, TRACELOG_RIGHTS.WMIGUID_QUERY, true), ResultIs.Successful);
Assert.That(EventAccessRemove(sess.ProviderGuid), ResultIs.Successful);
}
static AclApiTests()
{
using (new ElevPriv("SeSecurityPrivilege"))
pSd = AdvApi32Tests.GetSD(AdvApi32Tests.fn, SecInfoAll);
}
public SecurityEventArg(SafePSECURITY_DESCRIPTOR sd, SECURITY_INFORMATION parts)
{
Parts = parts;
SecurityDesciptor = sd;
}
/// <summary>Converts a security descriptor to its SDDL string format.</summary> /// <param name="pSD">The security descriptor.</param> /// <param name="si">The elements of the security descriptor to return.</param> /// <returns>The SDDL string representation of the security descriptor.</returns> public static string ToSddl(this SafePSECURITY_DESCRIPTOR pSD, SECURITY_INFORMATION si) => ConvertSecurityDescriptorToStringSecurityDescriptor(pSD, si);
public void RegCreateDeleteOpenKeyExTest()
{
const string regKey = "Software";
Assert.That(RegOpenKeyEx(HKEY.HKEY_CURRENT_USER, regKey, RegOpenOptions.REG_OPTION_NON_VOLATILE, REGSAM.KEY_ALL_ACCESS,
out var hPKey), ResultIs.Successful);
using (hPKey)
{
Assert.That(RegCreateKeyEx(hPKey, tmpRegKey, samDesired: REGSAM.KEY_ALL_ACCESS, phkResult: out var hKey, lpdwDisposition: out _), ResultIs.Successful);
try
{
using (hKey)
{
using (var pSD = new SafePSECURITY_DESCRIPTOR(256))
{
Assert.That(SetSecurityDescriptorOwner(pSD, SafePSID.Current, false), ResultIs.Successful);
Assert.That(RegSetKeySecurity(hKey, SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION, pSD), ResultIs.Successful);
using (var pSD2 = new SafePSECURITY_DESCRIPTOR(256))
{
var sdsz = (uint)pSD2.Size;
Assert.That(RegGetKeySecurity(hKey, SECURITY_INFORMATION.OWNER_SECURITY_INFORMATION, pSD2, ref sdsz), ResultIs.Successful);
}
}
using (var mem = new SafeHGlobalHandle(1024))
{
var memSz = (uint)mem.Size;
const int val = 255;
ulong ulongVal = val;
var byteVal = BitConverter.GetBytes((uint)val);
var strVal = val.ToString();
Assert.That(RegSetKeyValue(hPKey, tmpRegKey, "V1", REG_VALUE_TYPE.REG_QWORD, new PinnedObject(ulongVal), 8), ResultIs.Successful);
Assert.That(RegGetValue(hPKey, tmpRegKey, "V1", RRF.RRF_RT_QWORD, out _, mem, ref memSz), ResultIs.Successful);
Assert.That(mem.ToStructure <ulong>(), Is.EqualTo(ulongVal));
Assert.That(RegSetKeyValue(hPKey, tmpRegKey, "V2", REG_VALUE_TYPE.REG_DWORD, byteVal, (uint)byteVal.Length), ResultIs.Successful);
memSz = mem.Size;
Assert.That(RegGetValue(hPKey, tmpRegKey, "V2", RRF.RRF_RT_DWORD, out _, mem, ref memSz), ResultIs.Successful);
Assert.That(mem.ToStructure <uint>(), Is.EqualTo((uint)val));
Assert.That(RegSetKeyValue(hPKey, tmpRegKey, "V3", REG_VALUE_TYPE.REG_SZ, strVal, (uint)StringHelper.GetByteCount(strVal)), ResultIs.Successful);
memSz = mem.Size;
Assert.That(RegGetValue(hPKey, tmpRegKey, "V3", RRF.RRF_RT_REG_SZ, out _, mem, ref memSz), ResultIs.Successful);
Assert.That(mem.ToString(-1, CharSet.Auto), Is.EqualTo(strVal));
memSz = mem.Size;
Assert.That(RegQueryMultipleValues(hKey, new[] { new VALENT("V1"), new VALENT("V2"), new VALENT("V3") }, 3, mem, ref memSz), ResultIs.Successful);
Assert.That(RegDeleteKeyValue(hPKey, tmpRegKey, "V1"), ResultIs.Successful);
Assert.That(RegDeleteKeyValue(hPKey, tmpRegKey, "V2"), ResultIs.Successful);
Assert.That(RegDeleteKeyValue(hPKey, tmpRegKey, "V3"), ResultIs.Successful);
Assert.That(RegSetValue(hKey, null, REG_VALUE_TYPE.REG_SZ, strVal), ResultIs.Successful);
var imemSz = (int)mem.Size;
Assert.That(RegQueryValue(hKey, null, mem, ref imemSz), ResultIs.Successful);
Assert.That(mem.ToString(-1, CharSet.Auto), Is.EqualTo(strVal));
Assert.That(RegDeleteValue(hKey, null), ResultIs.Successful);
Assert.That(RegSetValueEx(hKey, "V1", 0, REG_VALUE_TYPE.REG_QWORD, new PinnedObject(ulongVal), 8), ResultIs.Successful);
memSz = mem.Size;
Assert.That(RegQueryValueEx(hKey, "V1", default, out _, mem, ref memSz), ResultIs.Successful);
