public void DoFailuresWithWmiEnabled()
{
int numberOfEvents = 50;
using (WmiEventWatcher eventListener = new WmiEventWatcher(numberOfEvents))
{
HashAlgorithmProvider hashProvider = new HashAlgorithmProvider(typeof(SHA1Managed), false);
InstrumentationAttacherFactory attacherFactory = new InstrumentationAttacherFactory();
IInstrumentationAttacher binder = attacherFactory.CreateBinder(hashProvider.GetInstrumentationEventProvider(), new object[] { "foo", true, true, true }, new ConfigurationReflectionCache());
binder.BindInstrumentation();
for (int i = 0; i < numberOfEvents; i++)
{
try
{
hashProvider.CreateHash(null);
}
catch (Exception)
{
}
}
eventListener.WaitForEvents();
Assert.AreEqual(numberOfEvents, eventListener.EventsReceived.Count);
}
}
public void ExceptionManagerGetsInstrumented()
{
container.AddExtension(new ExceptionHandlingBlockExtension());
ExceptionManager manager = container.Resolve <ExceptionManager>();
Assert.IsNotNull(manager);
Exception exceptionToThrow = new Exception("some message");
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
try
{
manager.HandleException(new Exception(), "non-existing policy");
}
catch (ExceptionHandlingException)
{
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual(typeof(ExceptionHandlingFailureEvent).Name,
eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("non-existing policy", eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
}
}
}
[Ignore] //TODO try a different instrumentation mechanism
public void CreatedProviderHasCorrectInstrumentationListener()
{
SecurityCacheProviderFactory factory = new SecurityCacheProviderFactory(GetConfigurationSource());
ISecurityCacheProvider provider = factory.Create("provider1");
Assert.AreEqual(typeof(MockSecurityCacheProvider), provider.GetType());
MockSecurityCacheProvider mockProvider = (MockSecurityCacheProvider)provider;
ISecurityCacheProviderInstrumentationProvider instrumentationProvider = mockProvider.GetInstrumentationProvder();
Assert.IsInstanceOfType(instrumentationProvider, typeof(SecurityCacheProviderInstrumentationProvider));
SecurityCacheProviderInstrumentationProvider castedProvider = (SecurityCacheProviderInstrumentationProvider)instrumentationProvider;
using (WmiEventWatcher eventWatcher = new WmiEventWatcher(1))
{
IToken token = new GuidToken();
castedProvider.FireSecurityCacheReadPerformed(SecurityEntityType.Identity, token);
eventWatcher.WaitForEvents();
Assert.AreEqual(1, eventWatcher.EventsReceived.Count);
Assert.AreEqual("SecurityCacheReadPerformedEvent", eventWatcher.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(SecurityEntityType.Identity.ToString(), eventWatcher.EventsReceived[0].Properties["EntityType"].Value);
Assert.AreEqual("provider1", eventWatcher.EventsReceived[0].Properties["InstanceName"].Value);
Assert.AreEqual(token.Value, eventWatcher.EventsReceived[0].Properties["TokenUsed"].Value);
}
}
public void DoLotsOfConnectionFailures()
{
int numberOfEvents = 50;
using (WmiEventWatcher eventListener = new WmiEventWatcher(numberOfEvents))
{
SqlDatabase db = new SqlDatabase("BadConnectionString");
DataInstrumentationListener listener = new DataInstrumentationListener("foo", true, true, true);
DataInstrumentationListenerBinder binder = new DataInstrumentationListenerBinder();
binder.Bind(db.GetInstrumentationEventProvider(), listener);
for (int i = 0; i < numberOfEvents; i++)
{
try
{
db.ExecuteScalar(CommandType.Text, "Select count(*) from Region");
}
catch { }
}
eventListener.WaitForEvents();
Assert.AreEqual(numberOfEvents, eventListener.EventsReceived.Count);
Assert.AreEqual("ConnectionFailedEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("foo", eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
Assert.AreEqual(db.ConnectionStringWithoutCredentials, eventListener.EventsReceived[0].GetPropertyValue("ConnectionString"));
}
}
public void WmiEventFiredWhenLoggingConfigurationIsCorrupt()
{
//corrupt the logging configuration
SysConfig.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
LoggingSettings rwLoggingSettings = (LoggingSettings)config.GetSection(LoggingSettings.SectionName);
string originalFirstTraceListenerName = rwLoggingSettings.TraceListeners.Get(0).Name;
rwLoggingSettings.TraceSources.Get(0).TraceListeners.Get(0).Name = "wrongName";
config.Save(ConfigurationSaveMode.Full);
ConfigurationManager.RefreshSection(LoggingSettings.SectionName);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
try
{
Logger.Write("Some message");
}
catch (ConfigurationErrorsException)
{
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("LoggingConfigurationFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
string exceptionMessage = (string)eventListener.EventsReceived[0].GetPropertyValue("ExceptionMessage");
Assert.IsTrue(exceptionMessage.Contains("wrongName"));
}
finally
{
//restore the logging configuration
rwLoggingSettings.TraceSources.Get(0).TraceListeners.Get(0).Name = originalFirstTraceListenerName;
config.Save(ConfigurationSaveMode.Full);
ConfigurationManager.RefreshSection(LoggingSettings.SectionName);
}
}
}
public void AuthorizationFailedFires2WmiEvents()
{
AzManAuthorizationProvider instrumentedAzman = new AzManAuthorizationProvider(data.StoreLocation, data.Application, data.AuditIdentifierPrefix, data.Scope);
AuthorizationProviderInstrumentationListener listener = new AuthorizationProviderInstrumentationListener("foo", false, false, true);
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(instrumentedAzman.GetInstrumentationEventProvider(), listener);
using (WmiEventWatcher eventWatcher = new WmiEventWatcher(2))
{
bool res = instrumentedAzman.Authorize(cryptographyProviderCollection, unauthorizedTask);
eventWatcher.WaitForEvents();
Assert.AreEqual(2, eventWatcher.EventsReceived.Count);
Assert.AreEqual("AuthorizationCheckPerformedEvent", eventWatcher.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("foo", eventWatcher.EventsReceived[0].Properties["InstanceName"].Value);
Assert.AreEqual(cryptographyProviderCollection.Identity.Name, eventWatcher.EventsReceived[0].Properties["UserName"].Value);
Assert.AreEqual(unauthorizedTask, eventWatcher.EventsReceived[0].Properties["TaskName"].Value);
Assert.AreEqual("AuthorizationCheckFailedEvent", eventWatcher.EventsReceived[1].ClassPath.ClassName);
Assert.AreEqual("foo", eventWatcher.EventsReceived[1].Properties["InstanceName"].Value);
Assert.AreEqual(cryptographyProviderCollection.Identity.Name, eventWatcher.EventsReceived[1].Properties["UserName"].Value);
Assert.AreEqual(unauthorizedTask, eventWatcher.EventsReceived[1].Properties["TaskName"].Value);
}
}
public void WmiFiredWhenDeliveryToErrorSourceFails()
{
TraceListener badTraceListener = new BadTraceListener(new Exception("test exception"));
LogSource badSource = new LogSource("badSource");
badSource.Listeners.Add(badTraceListener);
Dictionary <string, LogSource> logSources = new Dictionary <string, LogSource>();
logSources.Add("foo", badSource);
LogWriter writer = new LogWriter(new List <ILogFilter>(), logSources, badSource, "foo");
new ReflectionInstrumentationBinder().Bind(writer.GetInstrumentationEventProvider(), new LoggingInstrumentationListener(false, false, true));
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
writer.Write(CommonUtil.GetDefaultLogEntry());
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("LoggingFailureLoggingErrorEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
string exceptionMessage = (string)eventListener.EventsReceived[0].GetPropertyValue("ExceptionMessage");
Assert.IsTrue(-1 != exceptionMessage.IndexOf("test exception"));
Assert.IsNotNull(eventListener.EventsReceived[0].GetPropertyValue("ErrorMessage"));
}
}
static void AppExitCleanUp(object sender, EventArgs e)
{
WmiEventWatcher.StopHpBiosEventWatcher();
GpuInfo.CloseGpuGroups();
CpuInfo.CloseCpuGroups();
Opcode.Close();
Ring0.Close();
}
[Ignore] // TODO try a different instrumentation mechanism
public void CallingThroughFacadeFiresWmiEvents()
{
using (WmiEventWatcher eventWatcher = new WmiEventWatcher(1))
{
Validation.Validate(this);
eventWatcher.WaitForEvents();
Assert.AreEqual(1, eventWatcher.EventsReceived.Count);
Assert.AreEqual("ValidationSucceededEvent", eventWatcher.EventsReceived[0].ClassPath.ClassName);
}
}
public void AuthorizationCheckDoesNotNotifyWmiIfDisabled()
{
new ReflectionInstrumentationBinder().Bind(instrumentationProvider, disabledInstrumentationListener);
using (WmiEventWatcher eventListener = new WmiEventWatcher(numberOfEvents))
{
FireAuthorizationCheckPerformed();
eventListener.WaitForEvents();
Assert.AreEqual(0, eventListener.EventsReceived.Count);
}
}
public void SecurityCacheCheckDoesNotifyWmiIfEnabled()
{
new ReflectionInstrumentationBinder().Bind(instrumentationProvider, enabledInstrumentationListener);
using (WmiEventWatcher eventListener = new WmiEventWatcher(numberOfEvents))
{
FireSecurityCacheReadPerformed();
eventListener.WaitForEvents();
Assert.AreEqual(numberOfEvents, eventListener.EventsReceived.Count);
}
}
public void ServicePausedFiresWmiEvent()
{
DistributorEventLogger logger = new DistributorEventLogger(TestApplicationName);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
logger.LogServicePaused();
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("DistributorServiceLifecycleEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(false, eventListener.EventsReceived[0].GetPropertyValue("Started"));
}
}
public void ServiceFailureWithExceptionFiresWmiEvent()
{
DistributorEventLogger logger = new DistributorEventLogger(TestApplicationName);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
logger.LogServiceFailure(message, GetException(), TraceEventType.Error);
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("DistributorServiceFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.IsTrue(((string)eventListener.EventsReceived[0].GetPropertyValue("FailureMessage")).StartsWith(message));
}
}
public void CacheScavengingWithInstrumentationDisabledDoesNotFireWmiEvent()
{
CachingInstrumentationListener listener
= new CachingInstrumentationListener(instanceName, false, false, false, formatter);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
CacheScavengedEventArgs args = new CacheScavengedEventArgs(10);
listener.CacheScavenged(null, args);
eventListener.WaitForEvents();
Assert.AreEqual(0, eventListener.EventsReceived.Count);
}
}
static void Main()
{
WmiEventWatcher.StartHpBiosEventWatcher();
Ring0.Open();
Opcode.Open();
GpuInfo.OpenGpuGroups();
CpuInfo.OpenCpuGroups();
Application.ApplicationExit += AppExitCleanUp;
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new FormMain());
}
public void CacheFailureWithInstrumentationDisabledDoesNotFireWmiEvent()
{
CachingInstrumentationListener listener
= new CachingInstrumentationListener(instanceName, false, false, false, formatter);
Exception exception = new Exception(exceptionMessage);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
CacheFailureEventArgs args = new CacheFailureEventArgs(errorMessage, exception);
listener.CacheFailed(null, args);
eventListener.WaitForEvents();
Assert.AreEqual(0, eventListener.EventsReceived.Count);
}
}
public void DefaultLoggerFiresWmiEvent()
{
DefaultCachingEventLogger logger
= new DefaultCachingEventLogger(false, true);
ConfigurationErrorsException exception = new ConfigurationErrorsException(exceptionMessage);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
logger.LogConfigurationError(instanceName, exception);
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("CacheConfigurationFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(instanceName, eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
}
}
static void Main(string[] args)
{
Action <string, string> wl = (a, b) => Console.WriteLine($"{a}: {b}");
WmiEventWatcher.HpBiosEventArrived += (sender, eventArgs) =>
{
Console.WriteLine("\n========");
wl("EventId", eventArgs.eventId.ToString());
wl("EventData", eventArgs.eventData.ToString());
wl("TimeCreated", eventArgs.timeCreated.ToString());
switch (eventArgs.eventPayload)
{
case OmenKeyPressedPayload:
Console.WriteLine("OMEN key pressed");
break;
case TouchPadTogglePayload x:
wl("TouchPad lock pressed, TouchPad is", x.IsTouchPadEnabled ? "Enabled" : "Disabled");
break;
case WinKeyLockPayload x:
wl("WinKey lock pressed, WinKey is", x.IsWinKeyEnabled ? "Enabled" : "Locked");
break;
case LowPowerAdapterPayload:
Console.WriteLine("Power Adapter has low power supply");
break;
case IncompatiblePowerAdapterPayload:
Console.WriteLine("Incompatible power adapter");
break;
case PowerAdapterPayload:
Console.WriteLine("Power adapter plugged in");
break;
}
Console.WriteLine("========\n");
};
WmiEventWatcher.StartHpBiosEventWatcher();
Console.Read();
WmiEventWatcher.StopHpBiosEventWatcher();
}
public void FailedValidateFiresWmiEvent()
{
ValidatorWrapper validator = new ValidatorWrapper(new MockValidator(true));
ValidationInstrumentationListener instrumentationListener = new ValidationInstrumentationListener(false, false, true);
new ReflectionInstrumentationBinder().Bind(validator.GetInstrumentationEventProvider(), instrumentationListener);
using (WmiEventWatcher eventWatcher = new WmiEventWatcher(1))
{
validator.Validate(this);
eventWatcher.WaitForEvents();
Assert.AreEqual(1, eventWatcher.EventsReceived.Count);
Assert.AreEqual("ValidationFailedEvent", eventWatcher.EventsReceived[0].ClassPath.ClassName);
}
}
public void CacheScavengingWithInstrumentationEnabledDoesFireWmiEvent()
{
CachingInstrumentationListener listener
= new CachingInstrumentationListener(instanceName, false, false, true, formatter);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
CacheScavengedEventArgs args = new CacheScavengedEventArgs(10);
listener.CacheScavenged(null, args);
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("CacheScavengedEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(instanceName, eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
Assert.AreEqual(10L, eventListener.EventsReceived[0].GetPropertyValue("ItemsScavenged"));
}
}
public void GetsHookedUpAndRaisesEvents()
{
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
try
{
manager.HandleException(new Exception(), "non-existing policy");
}
catch (ExceptionHandlingException)
{
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual(typeof(ExceptionHandlingFailureEvent).Name,
eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("non-existing policy", eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
}
}
}
public void CacheCallbackFailureWithInstrumentationEnabledDoesFireWmiEvent()
{
CachingInstrumentationListener listener
= new CachingInstrumentationListener(instanceName, false, false, true, formatter);
Exception exception = new Exception(exceptionMessage);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
CacheCallbackFailureEventArgs args = new CacheCallbackFailureEventArgs(key, exception);
listener.CacheCallbackFailed(null, args);
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("CacheCallbackFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(key, eventListener.EventsReceived[0].GetPropertyValue("Key"));
Assert.IsTrue(eventListener.EventsReceived[0].GetPropertyValue("ExceptionMessage").ToString().IndexOf(exceptionMessage) > -1);
}
}
public void WmiEventFiredWhenCreatingUndefinedPolicy()
{
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
try
{
ExceptionPolicy.HandleException(new Exception(), "ThisIsAnUnknownKey");
}
catch (ConfigurationErrorsException)
{
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("ExceptionHandlingConfigurationFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("ThisIsAnUnknownKey", eventListener.EventsReceived[0].GetPropertyValue("PolicyName"));
string exceptionMessage = (string)eventListener.EventsReceived[0].GetPropertyValue("ExceptionMessage");
Assert.IsFalse(-1 == exceptionMessage.IndexOf("ThisIsAnUnknownKey"));
}
}
}
public void CommandFailureFiresWmiEvent()
{
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
Database db = DatabaseFactory.CreateDatabase();
try
{
db.ExecuteNonQuery(CommandType.StoredProcedure, "BadCommandText");
}
catch { }
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("CommandFailedEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("Service_Dflt", eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
Assert.AreEqual(db.ConnectionStringWithoutCredentials, eventListener.EventsReceived[0].GetPropertyValue("ConnectionString"));
Assert.AreEqual("BadCommandText", eventListener.EventsReceived[0].GetPropertyValue("CommandText"));
}
}
public void AuthorizeFiresWmiEvent()
{
AzManAuthorizationProvider instrumentedAzman = new AzManAuthorizationProvider(data.StoreLocation, data.Application, data.AuditIdentifierPrefix, data.Scope);
AuthorizationProviderInstrumentationListener listener = new AuthorizationProviderInstrumentationListener("foo", false, false, true);
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(instrumentedAzman.GetInstrumentationEventProvider(), listener);
using (WmiEventWatcher eventWatcher = new WmiEventWatcher(1))
{
bool res = instrumentedAzman.Authorize(cryptographyProviderCollection, authorizedTask);
eventWatcher.WaitForEvents();
Thread.Sleep(500);
Assert.AreEqual(1, eventWatcher.EventsReceived.Count);
Assert.AreEqual("foo", eventWatcher.EventsReceived[0].Properties["InstanceName"].Value);
Assert.AreEqual(cryptographyProviderCollection.Identity.Name, eventWatcher.EventsReceived[0].Properties["UserName"].Value);
Assert.AreEqual(authorizedTask, eventWatcher.EventsReceived[0].Properties["TaskName"].Value);
}
}
public void RetrieveCachedPrincipalFiresWmiEvent()
{
SecurityCacheProvider securityCache = SecurityCacheFactory.GetSecurityCacheProvider() as SecurityCacheProvider;
SecurityCacheProviderInstrumentationListener listener = new SecurityCacheProviderInstrumentationListener("foo", false, false, true);
ReflectionInstrumentationBinder binder = new ReflectionInstrumentationBinder();
binder.Bind(securityCache.GetInstrumentationEventProvider(), listener);
using (WmiEventWatcher eventWatcher = new WmiEventWatcher(1))
{
IToken token = new GuidToken();
object profile = securityCache.GetPrincipal(token);
eventWatcher.WaitForEvents();
Assert.AreEqual(1, eventWatcher.EventsReceived.Count);
Assert.AreEqual("SecurityCacheReadPerformedEvent", eventWatcher.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual(SecurityEntityType.Principal.ToString(), eventWatcher.EventsReceived[0].Properties["EntityType"].Value);
Assert.AreEqual("foo", eventWatcher.EventsReceived[0].Properties["InstanceName"].Value);
Assert.AreEqual(token.Value, eventWatcher.EventsReceived[0].Properties["TokenUsed"].Value);
}
}
[Ignore] // TODO replace with other instrumentation mechanism for tests?
public void CryptographyManagerGetsInstrumented()
{
using (var container = CreateContainer())
{
CryptographyManager manager = container.Resolve <CryptographyManager>();
Assert.IsNotNull(manager);
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
try
{
manager.CreateHash("foo", "");
}
catch (ConfigurationErrorsException)
{
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("foo", eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
}
}
}
}
public void WmiEventFiredWhenAskingForDatabaseWithUnknownName()
{
using (WmiEventWatcher eventListener = new WmiEventWatcher(1))
{
try
{
Database db = DatabaseFactory.CreateDatabase("ThisIsAnUnknownKey");
}
catch (ConfigurationErrorsException)
{
eventListener.WaitForEvents();
Assert.AreEqual(1, eventListener.EventsReceived.Count);
Assert.AreEqual("DataConfigurationFailureEvent", eventListener.EventsReceived[0].ClassPath.ClassName);
Assert.AreEqual("ThisIsAnUnknownKey", eventListener.EventsReceived[0].GetPropertyValue("InstanceName"));
string exceptionMessage = (string)eventListener.EventsReceived[0].GetPropertyValue("ExceptionMessage");
Assert.IsFalse(-1 == exceptionMessage.IndexOf("ThisIsAnUnknownKey"));
return;
}
Assert.Fail("ConfigurationErrorsException expected");
}
}
