public IEnumerable<WmiObject> GetWmiObjectsForNetworkInterfacesAdapter()
{
WmiObject networkInterfaceAdapter = new WmiObject();
networkInterfaceAdapter.Add("Index", 6);
networkInterfaceAdapter.Add("PhysicalAdapter", true);
networkInterfaceAdapter.Add("AdapterTypeId", 0);
List<WmiObject> wmiObjects = new List<WmiObject>();
wmiObjects.Add(networkInterfaceAdapter);
return wmiObjects;
}
private WmiObject createWmiObjectsFromSingleObject(ManagementObject managementObject)
{
WmiObject wmiObject = new WmiObject();
foreach (PropertyData property in managementObject.Properties)
{
wmiObject.Add(property.Name, managementObject.GetPropertyValue(property.Name));
}
return(wmiObject);
}
public IEnumerable<WmiObject> GetWmiObjectsForComputerSystemQuery()
{
WmiObject system = new WmiObject();
system.Add("SystemType", "X86-based PC");
system.Add("DNSHostName", "MSS-RJ-220");
system.Add("PartOfDomain", true);
system.Add("Domain", "mss.modulo.com.br");
system.Add("Name","MSS-RJ-220");
List<WmiObject> wmiObjects = new List<WmiObject>();
wmiObjects.Add(system);
return wmiObjects;
}
private WmiObject createWmiObjectWithProperties(
ManagementBaseObject systemObject, string parentPropertyName, IList <String> outParameters)
{
WmiObject wmiObject = new WmiObject();
foreach (var outParameterName in outParameters)
{
string newResultItemKey = string.Format("{0}.{1}", parentPropertyName, outParameterName);
object newResultItemValue = this.getInvokeResultItemValue(systemObject, outParameterName);
wmiObject.Add(newResultItemKey, newResultItemValue);
}
return(wmiObject);
}
private IEnumerable <WmiObject> createWmiObjectsFromObjectSearcher(ManagementObjectSearcher wmiObjectSearcher)
{
List <WmiObject> wmiObjects = new List <WmiObject>();
foreach (ManagementObject managementObject in wmiObjectSearcher.Get())
{
WmiObject wmiObject = new WmiObject();
foreach (PropertyData property in managementObject.Properties)
{
wmiObject.Add(property.Name, managementObject.GetPropertyValue(property.Name));
}
wmiObjects.Add(wmiObject);
}
return(wmiObjects);
}
public void Should_be_possible_to_collect_FileEffectiveRights()
{
// Arrange
WmiObject fakeWmiObject = new WmiObject();
fakeWmiObject.Add("Descriptor.DACL.AccessMask", (uint)128);
fakeWmiObject.Add("Descriptor.DACL.AceFlags", (uint)123);
fakeWmiObject.Add("Descriptor.DACL.Trustee.SID", "{500}");
fakeWmiObject.Add("Descriptor.DACL.Trustee.Domain", "mss");
fakeWmiObject.Add("Descriptor.DACL.Trustee.Name", "lfernandes");
MockRepository mocks = new MockRepository();
WmiDataProvider fakeWmiDataProvider = mocks.DynamicMock<WmiDataProvider>();
Expect.Call(fakeWmiDataProvider.InvokeMethodByWmiPath(null)).IgnoreArguments().Return(new WmiObject[] { fakeWmiObject });
FileEffectiveRightsObjectCollector fileEffectiveRightsSysDataSource = new FileEffectiveRightsObjectCollector();
fileEffectiveRightsSysDataSource.WmiDataProvider = fakeWmiDataProvider;
mocks.ReplayAll();
// Act
IEnumerable<CollectedItem> collectedItem = fileEffectiveRightsSysDataSource.CollectDataForSystemItem(this.getFakeFileItem());
Assert.IsNotNull(collectedItem, "The return of collect data cannot be null");
Assert.AreEqual(1, collectedItem.Count(), "Unexpected collected items count.");
Assert.IsNotNull(collectedItem.ElementAt(0).ItemType, "The file item cannot be null.");
Assert.IsInstanceOfType(collectedItem.ElementAt(0).ItemType, typeof(fileeffectiverights_item), "The item of collected item must be file_item");
fileeffectiverights_item collectedFileEffectiveRights = (fileeffectiverights_item)collectedItem.ElementAt(0).ItemType;
Assert.AreEqual("{500}", collectedFileEffectiveRights.trustee_sid.Value, "Unexpected item value.");
Assert.AreEqual("1", collectedFileEffectiveRights.file_read_attributes.Value, "Unexpected file attribute found.");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_append_data, false, "file_append_data");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_delete_child, false, "file_delete_child");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_execute, false, "file_execute");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_read_data, false, "file_read_data");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_read_ea, false, "file_read_ea");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_write_attributes, false, "file_write_attributes");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_write_data, false, "file_write_data");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.file_write_ea, false, "file_write_ea");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.generic_all, true, "generic_all");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.generic_execute, true, "generic_execute");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.generic_read, true, "generic_read");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.generic_write, false, "generic_write");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.standard_delete, false, "standard_delete");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.standard_read_control, false, "standard_delete");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.standard_synchronize, false, "standard_sync");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.standard_write_dac, false, "standard_write_dac");
this.AssertFileEffectiveRight(collectedFileEffectiveRights.standard_write_owner, false, "standard_write_owner");
}
private string GetArchitecture(WmiObject wmiObject)
{
string systemType = wmiObject.GetValueOf("SystemType").ToString();
switch (systemType)
{
case "X86-based PC":
case "X86-Nec98 PC":
systemType = "INTEL32";
break;
case "MIPS-based PC":
systemType = "MIPS";
break;
case "Alpha-based PC":
systemType = "ALPHA32";
break;
case "Power PC":
systemType = "POWERPC32";
break;
case "SH-x PC":
systemType = "SUPERH";
break;
case "StrongARM PC":
systemType = "STRONGARM";
break;
case "64-bit Intel PC":
systemType = "INTEL64";
break;
case "64-bit Alpha PC":
systemType = "ALPHA64";
break;
default:
systemType = "UNKNOWN";
break;
}
return systemType;
}
private IEnumerable<WmiObject> CreateFakeWmiObjectList(string wmiFieldName, string[] wmiFieldValues)
{
var result = new List<WmiObject>();
foreach (var wmiFieldValue in wmiFieldValues)
{
var fakeWmiObject = new WmiObject();
fakeWmiObject.Add(wmiFieldName, wmiFieldValue);
result.Add(fakeWmiObject);
}
return result;
}
private IEnumerable<WmiObject> CreateFakeWmiReturn()
{
var wmiObject = new WmiObject();
wmiObject.Add("name", "cpaiva");
wmiObject.Add("domain", "mss");
var wmiObject2 = new WmiObject();
wmiObject2.Add("name", "jcastro");
wmiObject2.Add("domain", "local");
return new WmiObject[] { wmiObject, wmiObject2 };
}
private WmiObject createFakeWmiObject(string accountDomain, string accountName, string isLocalAccount, string wmiClassName)
{
WmiObject fakeWmiObject = new WmiObject();
fakeWmiObject.Add("__CLASS", wmiClassName);
fakeWmiObject.Add("Description", "Administrator have complete and unrestricted access to the computer/domain");
fakeWmiObject.Add("Domain", accountDomain);
fakeWmiObject.Add("Name", accountName);
fakeWmiObject.Add("InstallDate", null);
fakeWmiObject.Add("LocalAccount", Boolean.Parse(isLocalAccount));
fakeWmiObject.Add(@"Caption", string.Format(@"{0}\{1}", accountDomain, accountName));
fakeWmiObject.Add("SID", Guid.NewGuid().ToString());
fakeWmiObject.Add("SIDType", (UInt16)4);
fakeWmiObject.Add("Status", "OK");
return fakeWmiObject;
}
private WmiObject NewWmiObjectForFakeLocalGroup(string groupName, string sid)
{
var newWmiObject = new WmiObject();
newWmiObject.Add("Name", groupName);
newWmiObject.Add("SID", sid);
return newWmiObject;
}
private WmiObject NewWmiObjectForFakeGroupUser(string name)
{
var partComponent = String.Format("\\\\{0}\\root\\cimv2:Win32_UserAccount.Domain=\"{0}\",Name=\"{1}\"", FAKE_COMPUTER_NAME, name);
var newWmiObject = new WmiObject();
newWmiObject.Add("PartComponent", partComponent);
return newWmiObject;
}
private WmiDataProvider GetWmiProviderMock(string usernameReturn, bool userDisabledReturn, params string[] groupNamesReturn)
{
var fakeWqlResult = new List<WmiObject>();
if (usernameReturn != null)
{
var fakeWmiObject = new WmiObject();
fakeWmiObject.Add("Domain", "fakeDomainOrComputername");
fakeWmiObject.Add("Name", usernameReturn);
fakeWmiObject.Add("Disabled", userDisabledReturn);
fakeWqlResult.Add(fakeWmiObject);
}
var mocks = new MockRepository();
var fakeWmiProvider = mocks.DynamicMock<WmiDataProvider>();
Expect.Call(fakeWmiProvider.ExecuteWQL(null)).IgnoreArguments().Return(fakeWqlResult);
mocks.ReplayAll();
return fakeWmiProvider;
}
private WmiDataProvider GetWmiProviderMockWithNoWmiResultBehavior()
{
// This mocked WmiDataProvider must be used in order to test GetAllGroupsByUser method.
var mocks = new MockRepository();
var fakeWmiProvider = mocks.StrictMock<WmiDataProvider>();
// Create expectation for first calling (to get computer name).
var wqlToGetComputerName = new WQLBuilder().WithWmiClass("Win32_ComputerSystem").Build();
var fakeWin32ComputerSystemRecord = new WmiObject();
fakeWin32ComputerSystemRecord.Add("Name", FAKE_COMPUTER_NAME);
fakeWin32ComputerSystemRecord.Add("DomainRole", 1);
Expect.Call(fakeWmiProvider.ExecuteWQL(wqlToGetComputerName)).Return(new[] { fakeWin32ComputerSystemRecord });
// Create expectation for second calling (to get all local groups);
var wqlToGetAllLocalGroups = new WQLBuilder().WithWmiClass("Win32_Group").AddParameter("localaccount", "1").Build();
var fakeWin32GroupRecords = new List<WmiObject>();
fakeWin32GroupRecords.Add(NewWmiObjectForFakeLocalGroup("Administrators", "S-1-5-32-544"));
fakeWin32GroupRecords.Add(NewWmiObjectForFakeLocalGroup("Backup Operators", "S-1-5-32-551"));
fakeWin32GroupRecords.Add(NewWmiObjectForFakeLocalGroup("Users", "S-1-5-32-545"));
Expect.Call(fakeWmiProvider.ExecuteWQL(wqlToGetAllLocalGroups)).Return(fakeWin32GroupRecords);
// Create expectation for each get group component calling...
CreateExpectationForGetGroupComponent(fakeWmiProvider, "Administrators");
CreateExpectationForGetGroupComponent(fakeWmiProvider, "Backup Operators");
CreateExpectationForGetGroupComponent(fakeWmiProvider, "Users");
// Create expectation for each get user details calling (3 first times) and get user SID (3 last times)
Expect.Call(fakeWmiProvider.ExecuteWQL(null)).IgnoreArguments().Repeat.Times(6).Return(null);
var wqlAllGetBuiltinAccounts = new WQLBuilder().WithWmiClass("Win32_SystemAccount").Build();
Expect.Call(fakeWmiProvider.ExecuteWQL(wqlAllGetBuiltinAccounts)).Return(null);
mocks.ReplayAll();
return fakeWmiProvider;
}
private void AssertCollectedFileItems(CollectedObject collectedObject, WmiObject[] expectedFiles)
{
string UNEXPECTED_ITEM_ATTRIBUTE_VALUE = "Unexpected value for a file_item attribute was found: {0}";
SystemCharacteristics::ReferenceType[] objectReferences = collectedObject.ObjectType.reference.ToArray();
IList<ItemType> fileItems = (IList<ItemType>)collectedObject.SystemData;
Assert.AreEqual(expectedFiles.Count(), objectReferences.Count(), "Unexpected number of item references was found.");
Assert.AreEqual(objectReferences.Count(), fileItems.Count, "Unexpected number of generated items type was found.");
int i = 0;
foreach (var expectedFile in expectedFiles)
{
Dictionary<string, object> fileItemFields = expectedFile.GetValues();
Assert.IsInstanceOfType(fileItems[i], typeof(file_item), "The generated ItemType must be a instance of file_item class.");
file_item fileItem = (file_item)fileItems[i];
Assert.AreEqual(objectReferences[i].item_ref, fileItem.id, "The generated ItemType ID must be equal to collected object ID.");
Assert.AreEqual(StatusEnumeration.exists, fileItem.status, "A generated ItemType with unexpected OVAL Status was found.");
Assert.AreEqual(fileItemFields[FILE_SIZE].ToString(), fileItem.size.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, FILE_SIZE));
Assert.AreEqual(ConvertWmiTimeToFileTime(fileItemFields[C_DATE].ToString()), fileItem.c_time.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, C_DATE));
Assert.AreEqual(ConvertWmiTimeToFileTime(fileItemFields[M_DATE].ToString()), fileItem.m_time.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, M_DATE));
Assert.AreEqual(ConvertWmiTimeToFileTime(fileItemFields[A_DATE].ToString()), fileItem.a_time.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, A_DATE));
Assert.AreEqual(fileItemFields[VERSION], fileItem.version.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, VERSION));
Assert.AreEqual(fileItemFields[FILE_TYPE], fileItem.type.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, FILE_SIZE));
Assert.AreEqual(fileItemFields[COMPANY], fileItem.company.Value, string.Format(UNEXPECTED_ITEM_ATTRIBUTE_VALUE, COMPANY));
i++;
}
}
public void Should_be_possible_to_execute_a_simple_file_collect_defined_with_one_entity()
{
// Arrange
var objectType = ProbeHelper.GetDefinitionObjectTypeByID("definitionsSimple.xml", "oval:modulo:obj:1");
var fakeCollectInfo = ProbeHelper.CreateFakeCollectInfo(new Definitions.ObjectType[] { objectType }, null, null);
var fakeWmiObjects = new WmiObject[] { this.createFakeWmiObject() };
var fakeFileItem = this.CreateFakeFileItem("c:\\temp\\file.txt", null, null);
var fileProber = this.CreateMockedFileProber(fakeWmiObjects, new ItemType[] { fakeFileItem }, null);
// Act
var collectedObjects = (List<CollectedObject>)fileProber.Execute(FakeContext, FakeTarget, fakeCollectInfo).CollectedObjects;
// Assert
Assert.IsNotNull(collectedObjects, "The result of file collect cannot be null");
Assert.IsNotNull(collectedObjects.Single(), string.Format("The object '{0}' was not found.", "oval:modulo:obj:1"));
this.AssertCollectedFileItems(collectedObjects.Single(), fakeWmiObjects);
this.AssertFilePathEntityExistence((file_item)collectedObjects.Single().SystemData[0]);
}
private WmiObject CreateFakeWmiObject(string completeFileName, string fileType, int fileSize)
{
var fakeWmiObject = new WmiObject();
fakeWmiObject.Add("Name", completeFileName);
fakeWmiObject.Add(GeneratedFileItemAttributes.FileSize.ToString(), fileSize);
fakeWmiObject.Add(GeneratedFileItemAttributes.CreationDate.ToString(), "20081217165939.013961 - 120");
fakeWmiObject.Add(GeneratedFileItemAttributes.LastModified.ToString(), "20090116171121.673899 - 120");
fakeWmiObject.Add(GeneratedFileItemAttributes.LastAccessed.ToString(), "20081217171525.895263 - 120");
fakeWmiObject.Add(GeneratedFileItemAttributes.Version.ToString(), "1");
fakeWmiObject.Add(GeneratedFileItemAttributes.FileType.ToString(), fileType);
fakeWmiObject.Add(GeneratedFileItemAttributes.Manufacturer.ToString(), "Modulo");
return fakeWmiObject;
}
private WmiObject createFakeWmiObject()
{
WmiObject fakeWmiObject = new WmiObject();
fakeWmiObject.Add(FILE_SIZE, 50);
fakeWmiObject.Add(C_DATE, "20081217165939.013961 - 120");
fakeWmiObject.Add(M_DATE, "20090116171121.673899 - 120");
fakeWmiObject.Add(A_DATE, "20081217171525.895263 - 120");
fakeWmiObject.Add(VERSION, "1");
fakeWmiObject.Add(FILE_TYPE, "Text Document");
fakeWmiObject.Add(COMPANY, "Modulo");
return fakeWmiObject;
}
/// <summary>
/// Gets the name of the system.
/// </summary>
/// <param name="wmiObject">The WMI object.</param>
/// <returns></returns>
private string GetSystemName(WmiObject wmiObject)
{
string osName = wmiObject.GetValueOf("Name").ToString();
osName = osName.Split('|')[0].Trim();
osName = osName.Replace("®", "");
osName = osName.Replace("™", "");
ushort spmajor = (ushort)wmiObject.GetValueOf("ServicePackMajorVersion");
ushort spminor = (ushort)wmiObject.GetValueOf("ServicePackMinorVersion");
if (spmajor > 0)
{
osName += " SP" + spmajor.ToString();
if (spminor > 0)
osName += "." + spminor.ToString();
}
return osName;
}
/// <summary>
/// Return the name of host name concatenated with the domain name.
/// </summary>
/// <param name="wmiObject">The WMI object.</param>
/// <returns></returns>
private string GetHostName(WmiObject wmiObject)
{
string hostName = wmiObject.GetFieldValueAsString("DNSHostName").ToLower();
if (string.IsNullOrEmpty(hostName))
hostName = wmiObject.GetFieldValueAsString("Name").ToLower();
object partOfDomain = wmiObject.GetValueOf("PartOfDomain");
if ((partOfDomain != null) && ((bool)partOfDomain))
{
hostName += "." + wmiObject.GetFieldValueAsString("Domain");
}
return hostName;
}
public void Should_be_possible_to_collect_a_FileObject_that_contains_a_referenced_variable()
{
// Arrange
var objectType = ProbeHelper.GetDefinitionObjectTypeByID("definitionsSimple.xml", "oval:modulo:obj:3");
var variables = VariableHelper.CreateVariableWithOneValue("oval:modulo:obj:3", "oval:modulo:var:3", "c:\\temp");
var fakeCollectInfo = ProbeHelper.CreateFakeCollectInfo(new Definitions.ObjectType[] { objectType }, variables, null);
var fakeWmiObjects = new WmiObject[] { this.createFakeWmiObject() };
var fakeFileItems = new ItemType[] { this.CreateFakeFileItem(null, "c:\\temp", "file1.txt") };
var fileProber = this.CreateMockedFileProber(fakeWmiObjects, fakeFileItems, null);
// Act
var collectedObjects = (List<CollectedObject>)fileProber.Execute(FakeContext, FakeTarget, fakeCollectInfo).CollectedObjects;
// Assert
Assert.IsNotNull(collectedObjects, "The result of file collect cannot be null");
Assert.IsNotNull(collectedObjects.Single(), string.Format("There is no collected object."));
this.AssertCollectedFileItems(collectedObjects.Single(), fakeWmiObjects);
var collectedItem = (file_item)collectedObjects.Single().SystemData[0];
this.AssertPathAndFileNameEntitiesExistence(collectedItem);
Assert.AreEqual("c:\\temp", collectedItem.path.Value, "The variable value was not set to file item entity.");
}
private WmiDataProvider GetMockedWmiDataProvider()
{
var fakeWmiObjects = new WmiObject[]
{ this.CreateFakeWmiObject(FAKE_DIR_PATH, FILE_TYPE_DIRECTORY, -1),
this.CreateFakeWmiObject(FAKE_FILE_PATH, FILE_TYPE_TEXTFILE, 50)
};
var mocks = new MockRepository();
var fakeWmiProvider = mocks.DynamicMock<WmiDataProvider>();
Expect.Call(fakeWmiProvider.SearchWmiObjects(null, null)).IgnoreArguments().Return(fakeWmiObjects);
mocks.ReplayAll();
return fakeWmiProvider;
}
private IEnumerable<WmiObject> createWmiObjectsFromObjectSearcher(ManagementObjectSearcher wmiObjectSearcher)
{
List<WmiObject> wmiObjects = new List<WmiObject>();
foreach (ManagementObject managementObject in wmiObjectSearcher.Get())
{
WmiObject wmiObject = new WmiObject();
foreach (PropertyData property in managementObject.Properties)
{
wmiObject.Add(property.Name, managementObject.GetPropertyValue(property.Name));
}
wmiObjects.Add(wmiObject);
}
return wmiObjects;
}
public IEnumerable<WmiObject> GetWmiObjectsForOperatingSystemQuery()
{
WmiObject os = new WmiObject();
os.Add("Version", "6.0.6002");
os.Add("Name", "Microsoft® Windows Server® 2008 Enterprise |C:\\Windows|\\Device\\Harddisk0\\Partition2");
os.Add("ServicePackMajorVersion", (ushort) 2);
os.Add("ServicePackMinorVersion", (ushort) 0);
List<WmiObject> wmiObjects = new List<WmiObject>();
wmiObjects.Add(os);
return wmiObjects;
}
private WmiObject createWmiObjectsFromSingleObject(ManagementObject managementObject)
{
WmiObject wmiObject = new WmiObject();
foreach (PropertyData property in managementObject.Properties)
wmiObject.Add(property.Name, managementObject.GetPropertyValue(property.Name));
return wmiObject;
}
public IEnumerable<WmiObject> GetWmiObjectsForNetworkInterfaces()
{
WmiObject networkInterface = new WmiObject();
networkInterface.Add("Index", 6);
networkInterface.Add("InterfaceIndex",10);
networkInterface.Add("Description", "Intel(R) 82567LM-3 Gigabit Network Connection");
networkInterface.Add("MACAddress", "00 - 23 - AE - B6 - 6F - BF");
networkInterface.Add("DHCPEnabled", true);
networkInterface.Add("IPAddress", new String[] { "172.16.3.166", "fe80::99ab:a003:a78e:103b" });
networkInterface.Add("IPSubnet", new String[] { "255.255.254.0", "64" });
networkInterface.Add("IPUseZeroBroadcast", false);
List<WmiObject> wmiObjects = new List<WmiObject>();
wmiObjects.Add(networkInterface);
return wmiObjects;
}
private WmiObject createWmiObjectWithProperties(
ManagementBaseObject systemObject, string parentPropertyName, IList<String> outParameters)
{
WmiObject wmiObject = new WmiObject();
foreach (var outParameterName in outParameters)
{
string newResultItemKey = string.Format("{0}.{1}", parentPropertyName, outParameterName);
object newResultItemValue = this.getInvokeResultItemValue(systemObject, outParameterName);
wmiObject.Add(newResultItemKey, newResultItemValue);
}
return wmiObject;
}
