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 override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
foreach (var entity in (((metabase_object)objectType).Items))
if (entity is set)
return (set)entity;
return null;
}
private bool IsFilePathSet(OVAL.Definitions.ObjectType objectType)
{
if (objectType is OVAL.Definitions.Windows.file_object)
return ((OVAL.Definitions.Windows.file_object)objectType).IsFilePathSet();
else if (objectType is OVAL.Definitions.Unix.file_object)
return ((OVAL.Definitions.Unix.file_object)objectType).IsFilePathSet();
else
throw new ArgumentException(String.Format("The object type '{0}' is not supported.", objectType.GetType().ToString()));
}
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());
}
public IEnumerable<ObjectType> CreateObjectTypeByCombinationOfEntities(OVAL.Definitions.Unix.file_object fileObject, IEnumerable<string> filePaths, IEnumerable<string> paths, IEnumerable<string> fileNames)
{
var fileObjects = new List<ObjectType>();
if (fileObject.IsFilePathSet())
fileObjects.AddRange(CreateFileObjectWithFilePath(fileObject, filePaths));
else
fileObjects.AddRange(this.CreateFileObjectWithoutFilePath(fileObject, paths, fileNames));
return fileObjects;
}
private IEnumerable<ItemType> CreateSmfItemWithErrorStatus(OVAL.Definitions.EntitySimpleBaseType fmriEntity)
{
var newItemWithErrorStatus = new smf_item()
{
status = StatusEnumeration.error,
message = MessageType.FromErrorString(String.Format(NOT_SUPPORTED_OPERATION_MESSAGE, fmriEntity.operation.ToString())),
fmri = new EntityItemStringType() { status = StatusEnumeration.error }
};
return new ItemType[] { newItemWithErrorStatus };
}
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 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 } });
}
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 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;
}
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;
}
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<ObjectType> ProcessVariables(OVAL.Definitions.Unix.file_object fileObject)
{
//var fileObject = (file_object)objectType;
var variablesFromFilePath = this.evaluateVariableForFileEntity(fileObject, OVAL.Definitions.Unix.ItemsChoiceType3.filepath);
if ((variablesFromFilePath != null) && (variablesFromFilePath.Count() > 0))
return new FileObjectTypeFactory().CreateObjectTypeByCombinationOfEntities(fileObject, variablesFromFilePath, null, null);
var variablesFromPath = this.evaluateVariableForFileEntity(fileObject, OVAL.Definitions.Unix.ItemsChoiceType3.path);
var variablesFromFilename = this.evaluateVariableForFileEntity(fileObject, OVAL.Definitions.Unix.ItemsChoiceType3.filename);
var isTherePath = (variablesFromPath != null) && (variablesFromPath.Count() > 0) && (variablesFromPath.Where<String>(v => v == null).Count() == 0);
if (isTherePath && (variablesFromFilename == null))
variablesFromFilename = new string[] { "" };
return new FileObjectTypeFactory().CreateObjectTypeByCombinationOfEntities(fileObject, null, variablesFromPath, variablesFromFilename);
}
public IEnumerable<ItemType> GetItemsToCollect(
OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
var engineValues = ProcessVariableForEntity(objectType, sql_object_choices.engine, variables);
var versionValues = ProcessVariableForEntity(objectType, sql_object_choices.version, variables);
var connectionStringValues = ProcessVariableForEntity(objectType, sql_object_choices.connection_string, variables);
var sqlValues = ProcessVariableForEntity(objectType, sql_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(sql_item.CreateSqlItem(engineValue, versionValue, connectionStringValue, sqlValue));
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;
}
protected override IEnumerable<Common.BasicClasses.CollectedItem> collectDataForSystemItem(OVAL.SystemCharacteristics.ItemType systemItem)
{
CiscoIOSVersion myVersion = CiscoIOSHelper.CiscoGetVersion(TelnetConnection);
version_item vItem = (version_item)systemItem;
vItem.mainline_rebuild = OvalHelper.CreateItemEntityWithStringValue(myVersion.MainlineRebuild);
vItem.major_release = OvalHelper.CreateItemEntityWithStringValue(myVersion.MajorRelease);
vItem.major_version = OvalHelper.CreateItemEntityWithIntegerValue(myVersion.MajorVersion.ToString());
vItem.minor_version = OvalHelper.CreateItemEntityWithIntegerValue(myVersion.MinorVersion.ToString());
if (myVersion.Rebuild >= 0)
vItem.rebuild = OvalHelper.CreateItemEntityWithIntegerValue(myVersion.Rebuild.ToString());
if (myVersion.Release >= 0)
vItem.release = OvalHelper.CreateItemEntityWithIntegerValue(myVersion.Release.ToString());
vItem.subrebuild = OvalHelper.CreateItemEntityWithStringValue(myVersion.SubRebuild);
vItem.train_identifier = OvalHelper.CreateItemEntityWithStringValue(myVersion.TrainIdentifier);
vItem.train_number = OvalHelper.CreateItemEntityWithStringValue(myVersion.TrainNumber);
vItem.version_string = new EntityItemIOSVersionType { Value = myVersion.VersionString };
return new ItemTypeHelper().CreateCollectedItemsWithOneItem(systemItem, BuildExecutionLog());
}
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 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 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;
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return null;
}
public IEnumerable<ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return new ItemType[] { this.createAuditEventPolicyItemType() };
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
var itemsElement = ((line_object)objectType).Items;
return itemsElement.OfType<set>().SingleOrDefault();
}
protected override OVAL.Definitions.set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return ((user_sid_object)objectType).GetSetEntity();
}
protected override set GetSetElement(OVAL.Definitions.ObjectType objectType)
{
return ((sql_object)objectType).GetSetElement();
}
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 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()));
}
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[] { new uname_item() };
}
public IEnumerable<ItemType> GetItemsToCollect(OVAL.Definitions.ObjectType objectType, VariablesEvaluated variables)
{
return new auditeventpolicysubcategories_item[] { CreateAuditEventPolicySubcategoriesItemType() };
}
