private IEnumerable <string> processOperation(OVAL.Definitions.ObjectType objectType, IEnumerable <String> evalutedVariables)
{
var trusteeEntity = ((sid_object)objectType).TrusteeName;
var entityOperation = trusteeEntity.operation;
string[] trusteeNames = string.IsNullOrEmpty(trusteeEntity.var_ref) ? new string[] { trusteeEntity.Value } : evalutedVariables.ToArray();
var operationResult = new List <String>();
foreach (var trusteeName in trusteeNames)
{
var valuesToApply = (this.getValuesToApplyOperation(entityOperation, trusteeName)).ToArray();
if (entityOperation == OperationEnumeration.patternmatch)
{
var multiLevelOperation = new MultiLevelPatternMatchOperation(FamilyEnumeration.windows);
operationResult.AddRange(multiLevelOperation.applyPatternMatch(trusteeName, valuesToApply));
}
else
{
operationResult.AddRange(this.EvaluateOperationsDifferentsOfPatternMatch(entityOperation, trusteeName, valuesToApply));
}
}
return(operationResult);
}
public IEnumerable <ItemType> GetItemsToCollect(
OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var engineValues = ProcessVariableForEntity(objectType, sql57_object_choices.engine, variables);
var versionValues = ProcessVariableForEntity(objectType, sql57_object_choices.version, variables);
var connectionStringValues = ProcessVariableForEntity(objectType, sql57_object_choices.connection_string, variables);
var sqlValues = ProcessVariableForEntity(objectType, sql57_object_choices.sql, variables);
IList <ItemType> itemsToCollect = new List <ItemType>();
foreach (var engineValue in engineValues)
{
foreach (var versionValue in versionValues)
{
foreach (var connectionStringValue in connectionStringValues)
{
foreach (var sqlValue in sqlValues)
{
itemsToCollect.Add(sql57_item.CreateSqlItem(engineValue, versionValue, connectionStringValue, sqlValue));
}
}
}
}
return(itemsToCollect);
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var variableEvaluator = new VariableEntityEvaluator(variables);
var fileEffectiveRightsObject = (fileeffectiverights53_object)objectType;
var paths = new List <String>();
var filenames = new List <String>();
if (fileEffectiveRightsObject.IsFilePathDefined())
{
var filepathEntity = (EntitySimpleBaseType)fileEffectiveRightsObject.GetItemValue(fileeffectiverights53_object_ItemsChoices.filepath);
var filepathValues = variableEvaluator.EvaluateVariableForEntity(filepathEntity);
filepathValues = this.ProcessOperationForFilepathEntity(filepathEntity.operation, filepathValues);
paths.AddRange(filepathValues.Select(filepath => Path.GetDirectoryName(filepath)).Distinct());
filenames.AddRange(filepathValues.Select(filepath => Path.GetFileName(filepath)).Distinct());
}
else
{
var pathEntity = (EntitySimpleBaseType)fileEffectiveRightsObject.GetItemValue(fileeffectiverights53_object_ItemsChoices.path);
var pathEntityValues = variableEvaluator.EvaluateVariableForEntity(pathEntity);
pathEntityValues = ProcessOperationForFilepathEntity(pathEntity.operation, pathEntityValues);
paths.AddRange(pathEntityValues);
var filenameEntity = (EntitySimpleBaseType)fileEffectiveRightsObject.GetItemValue(fileeffectiverights53_object_ItemsChoices.filename);
if (filenameEntity == null)
{
filenames.Add(string.Empty);
}
else
{
var filenameEntityValues = variableEvaluator.EvaluateVariableForEntity(filenameEntity);
filenameEntityValues = ProcessOperationForFilenameEntity(filenameEntity.operation, filenameEntityValues, pathEntityValues);
filenames.AddRange(filenameEntityValues.Distinct());
}
}
var trusteeSidEntity = (EntitySimpleBaseType)fileEffectiveRightsObject.GetItemValue(fileeffectiverights53_object_ItemsChoices.trustee_sid);
var trusteeSidEntityValues = variableEvaluator.EvaluateVariableForEntity(trusteeSidEntity);
var itemsToCollect = new List <ItemType>();
foreach (var path in paths)
{
foreach (var filename in filenames)
{
foreach (var trusteeSID in trusteeSidEntityValues)
{
var newItems = ProcessOperationForTrusteeSidEntity(path, filename, trusteeSID, trusteeSidEntity.operation);
itemsToCollect.AddRange(newItems);
}
}
}
return(itemsToCollect);
}
private IEnumerable <string> ProcessVariableForEntity(
OVAL.Definitions.ObjectType sourceObject,
sql57_object_choices entityName,
VariablesEvaluated evaluatedVariables)
{
var entity = ((sql57_object)sourceObject).GetObjectEntityByName(entityName);
return(new VariableEntityEvaluator(evaluatedVariables).EvaluateVariableForEntity(entity));
}
protected CollectInfo GetFakeCollectInfo(
string objectTypeID,
string definitionsFilename = "definitionsSimple.xml",
string systemCharacteristicsFilename = null)
{
var fakeObjectType = ProbeHelper.GetDefinitionObjectTypeByID(definitionsFilename, objectTypeID);
var fakeObjectTypes = new OVAL.Definitions.ObjectType[] { fakeObjectType };
var fakeSysCharacteristics = ProbeHelper.GetOvalSystemCharacteristicsFromFile(systemCharacteristicsFilename);
return(ProbeHelper.CreateFakeCollectInfo(fakeObjectTypes, null, fakeSysCharacteristics));
}
public UserSID55ItemTypeGeneratorTest()
{
this.DefaultUserSidItemTypeGenerator = new UserSID55ItemTypeGenerator(null);
var objectSamples = ProbeHelper.GetFakeOvalDefinitions("definitionsSimple.xml").objects;
this.UserSidObject1080 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1080"));
this.UserSidObject1090 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1090"));
this.UserSidObject1100 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1100"));
this.UserSidObject1101 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1101"));
this.UserSidObject1102 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1102"));
}
public virtual IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var serviceNameEntity = ((runlevel_object)objectType).GetItemValue("service_name");
var serviceNameValues = this.EvaluateVariable((EntityObjectStringType)serviceNameEntity, variables);
IEnumerable <string> serviceUniverse = null;
var operation = ((EntitySimpleBaseType)serviceNameEntity).operation;
if (operation == OperationEnumeration.patternmatch)
{
serviceUniverse = GetServiceUniverse();
serviceNameValues = this.DoPatternMatch(serviceNameValues, serviceUniverse);
}
else if (operation == OperationEnumeration.notequal)
{
serviceUniverse = GetServiceUniverse();
serviceNameValues = this.NotEqualOperation(serviceNameValues, serviceUniverse);
}
var runLevelEntity = ((runlevel_object)objectType).GetItemValue("runlevel");
var runLevelValues = this.EvaluateVariable((EntityObjectStringType)runLevelEntity, variables);
var runLevelOperation = ((EntitySimpleBaseType)runLevelEntity).operation;
if (runLevelOperation == OperationEnumeration.patternmatch)
{
var runlevelUniverse = GetRunlevelUniverse();
runLevelValues = this.DoPatternMatch(runLevelValues, runlevelUniverse);
}
else if (runLevelOperation == OperationEnumeration.notequal)
{
var runlevelUniverse = GetRunlevelUniverse();
runLevelValues = this.NotEqualOperation(runLevelValues, runlevelUniverse);
}
var itemsToCollect = new List <ItemType>();
foreach (var serviceName in serviceNameValues)
{
foreach (var runLevelName in runLevelValues)
{
var newItemToCollect = new runlevel_item()
{
service_name = OvalHelper.CreateItemEntityWithStringValue(serviceName),
runlevel = OvalHelper.CreateItemEntityWithStringValue(runLevelName)
};
itemsToCollect.Add(newItemToCollect);
}
}
return(itemsToCollect);
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, OVAL.Definitions.variableEvaluator.VariablesEvaluated variables)
{
var metabaseObject = (metabase_object)objectType;
var variableEvaluator = new VariableEntityEvaluator(variables);
var idEntityValues = variableEvaluator.EvaluateVariableForEntity(metabaseObject.GetIdEntity());
var keyEntityValues = variableEvaluator.EvaluateVariableForEntity(metabaseObject.GetKeyEntity());
var allIdsAfterOperation = this.ProcessOperationForIdEntity(metabaseObject.GetIdEntity(), idEntityValues);
var allKeysAfterOperation = this.ProcessOperationForKeyEntity(metabaseObject.GetKeyEntity(), keyEntityValues);
return(CreateMetabaseItems(allKeysAfterOperation, allIdsAfterOperation));
}
public UserSID55ItemTypeGeneratorTest()
{
this.DefaultUserSidItemTypeGenerator = new UserSID55ItemTypeGenerator(null);
var objectSamples = ProbeHelper.GetFakeOvalDefinitions("definitionsSimple.xml").objects;
this.UserSidObject1080 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1080"));
this.UserSidObject1090 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1090"));
this.UserSidObject1100 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1100"));
this.UserSidObject1101 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1101"));
this.UserSidObject1102 = objectSamples.Single(obj => obj.id.Equals("oval:modulo:obj:1102"));
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
foreach (var entity in (((metabase_object)objectType).Items))
{
if (entity is set)
{
return((set)entity);
}
}
return(null);
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var trusteeNames = this.processVariables(objectType, variables);
if (trusteeNames == null)
{
return(new List <ItemType>());
}
var derivedTrusteeNames = this.processOperation(objectType, trusteeNames.ToArray());
return(this.createSidItemsToCollect(derivedTrusteeNames.ToList()));
}
private IEnumerable <String> processVariables(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
string trusteeNameEntityValue = ((sid_object)objectType).TrusteeName.Value;
if ((variables == null) || (variables.VariableValues.Count() == 0))
{
return(new List <String>(new string[] { trusteeNameEntityValue }));
}
else
{
var variableEvaluator = new SIDEntityVariableEvaluator(objectType, variables);
var processedVariables = variableEvaluator.ProcessVariableForAllObjectEntities();
return((processedVariables == null) ? null : processedVariables);
}
}
public static Dictionary <String, EntityObjectStringType> GetFileEntitiesFromObjectType(
OVAL.Definitions.ObjectType objectType)
{
var filenameEntityName = GetFilenameEntityName(objectType);
var filepathEntityName = GetFilepathEntityName(objectType);
var pathEntityName = GetPathEntityName(objectType);
object[] allEntities = GetAllItems(objectType);
string[] allEntityNames = GetAllElementNames(objectType);
var fileEntities = new Dictionary <String, EntityObjectStringType>();
fileEntities.Add(filenameEntityName, OvalHelper.GetEntityObjectByName(filenameEntityName, allEntities, allEntityNames));
fileEntities.Add(filepathEntityName, OvalHelper.GetEntityObjectByName(filepathEntityName, allEntities, allEntityNames));
fileEntities.Add(pathEntityName, OvalHelper.GetEntityObjectByName(pathEntityName, allEntities, allEntityNames));
return(fileEntities);
}
private static string GetFilenameEntityName(OVAL.Definitions.ObjectType objectType)
{
var windowsFileObjectType = typeof(OVAL.Definitions.Windows.file_object);
var unixFileObjectType = typeof(OVAL.Definitions.Unix.file_object);
if (objectType.GetType().Equals(windowsFileObjectType))
{
return(file_object_ItemsChoices.filename.ToString());
}
else if (objectType.GetType().Equals(unixFileObjectType))
{
return(OVAL.Definitions.Unix.ItemsChoiceType3.filename.ToString());
}
else
{
throw new ArgumentException(String.Format("This object type '{0}' is not supported.", objectType.GetType().ToString()));
}
}
public virtual IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var variableNameEntity = ((environmentvariable_object)objectType).GetEnvironmentVariableNameEntity();
var variableNameValues = this.EvaluateVariable(variableNameEntity, variables);
var itemsToCollect = new List <ItemType>();
foreach (var variableName in variableNameValues)
{
var newItemToCollect = new environmentvariable_item()
{
name = OvalHelper.CreateItemEntityWithStringValue(variableName)
};
itemsToCollect.Add(newItemToCollect);
}
return(itemsToCollect);
}
private static string[] GetAllElementNames(OVAL.Definitions.ObjectType objectType)
{
var windowsFileObjectType = typeof(OVAL.Definitions.Windows.file_object);
var unixFileObjectType = typeof(OVAL.Definitions.Unix.file_object);
if (objectType.GetType().Equals(typeof(OVAL.Definitions.Windows.file_object)))
{
return(((OVAL.Definitions.Windows.file_object)objectType).FileObjectItemsElementName.Select(i => i.ToString()).ToArray <String>());
}
else if (objectType.GetType().Equals(typeof(OVAL.Definitions.Unix.file_object)))
{
return(((OVAL.Definitions.Unix.file_object)objectType).ItemsElementName.Select(i => i.ToString()).ToArray <String>());
}
else
{
throw new ArgumentException(String.Format("This object type '{0}' is not supported.", objectType.GetType().ToString()));
}
}
public IEnumerable <OVAL.SystemCharacteristics.ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var showSubcommandEntity = ((line_object)objectType).GetShowSubcommandEntity();
var showSubcommandValues =
new VariableEntityEvaluator(variables)
.EvaluateVariableForEntity(showSubcommandEntity);
return
(showSubcommandValues
.Select(v =>
new line_item()
{
show_subcommand = new EntityItemStringType()
{
Value = v
}
}));
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var usernameEntity = ((password_object)objectType).Items.OfType <EntityObjectStringType>().FirstOrDefault();
if (usernameEntity != null)
{
var usernames = new VariableEntityEvaluator(variables).EvaluateVariableForEntity(usernameEntity);
return
(usernames
.Select(
user =>
new password_item()
{
username = OvalHelper.CreateItemEntityWithStringValue(user)
}));
}
return(null);
}
public virtual IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var packageNameEntity = (Modulo.Collect.OVAL.Definitions.EntityObjectStringType)((rpminfo_object)objectType).Items.OfType <EntityObjectStringType>().FirstOrDefault();
var packageNameValues = this.EvaluateVariable(packageNameEntity, variables);
packageNameValues = ProcessOperationForEntity(packageNameEntity, packageNameValues);
var itemsToCollect = new List <ItemType>();
foreach (var packageName in packageNameValues)
{
var newItemToCollect = new rpminfo_item()
{
name = OvalHelper.CreateItemEntityWithStringValue(packageName)
};
itemsToCollect.Add(newItemToCollect);
}
return(itemsToCollect);
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var fmriEntity = ((OVAL.Definitions.Solaris.smf_object)objectType).GetFmriEntity();
if (fmriEntity.operation != OperationEnumeration.equals)
{
return(CreateSmfItemWithErrorStatus(fmriEntity));
}
var fmriValues = new VariableEntityEvaluator(variables).EvaluateVariableForEntity(fmriEntity);
var itemsToCollect = new List <ItemType>();
foreach (var fmriValue in fmriValues)
{
var newSmfItem = new smf_item()
{
fmri = OvalHelper.CreateItemEntityWithStringValue(fmriValue)
};
itemsToCollect.Add(newSmfItem);
}
return(itemsToCollect);
}
public new IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return(base.GetItemsToCollect(objectType, variables));
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
var itemsElement = ((line_object)objectType).Items;
return(itemsElement.OfType <set>().SingleOrDefault());
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return(new auditeventpolicysubcategories_item[] { CreateAuditEventPolicySubcategoriesItemType() });
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return(new ItemType[] { new lockoutpolicy_item() });
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return(null);
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return(((sql57_object)objectType).GetSetElement());
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return(new ItemType[] { new Modulo.Collect.OVAL.SystemCharacteristics.Ios.version_item() });
}
protected override OVAL.Definitions.set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return(((wmi57_object)objectType).Items.OfType <set>().FirstOrDefault());
}
public IEnumerable <ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return(new ItemType[] { this.createAuditEventPolicyItemType() });
}
protected override OVAL.Definitions.set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return(objectType.GetEntityBaseTypes().OfType <OVAL.Definitions.set>().SingleOrDefault());
}
protected override bool HasVariableDefined(OVAL.Definitions.ObjectType objectType)
{
return(((OVAL.Definitions.Unix.file_object)objectType).HasVariableDefined());
}
