private IEnumerable <String> ProcessOperationForKeyEntity( EntityObjectStringType keyEntity, IEnumerable <string> currentKeyValues) { if (keyEntity.operation.Equals(OperationEnumeration.equals)) { return(currentKeyValues); } var result = new List <String>(); var allMetabaseKeys = this.ObjectCollector.GetAllMetabaseKeys(); var ovalComparator = new OvalComparatorFactory().GetComparator(keyEntity.datatype); foreach (var keyValue in currentKeyValues) { foreach (var metabaseKey in allMetabaseKeys) { if (ovalComparator.Compare(metabaseKey, keyValue, keyEntity.operation)) { result.Add(metabaseKey); } } } return(result); }
private List <String> processTrusteeSID(string trusteeSID, string[] valuesToComparer) { var objectCollector = ((RegKeyEffectiveRightsObjectCollector)this.SystemDataSource); if ((valuesToComparer == null) || (valuesToComparer.Count() == 0)) { valuesToComparer = objectCollector.SearchUserTrusteeSIDs().ToArray(); } var result = new List <String>(); var comparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); foreach (var sidToCompare in valuesToComparer) { //var hasRegKeyUserDACL = // objectCollector.IsThereDACLOnRegistryKeyForUser( // HiveObjectEntity.Value, KeyObjectEntity.Value, sidToCompare); //if (!hasRegKeyUserDACL) // continue; if (comparator.Compare(sidToCompare, trusteeSID, this.TrusteeSIDObjectEntity.operation)) { result.Add(sidToCompare); } } return(result); }
private bool Compare(EntityItemSimpleBaseType valueOfFieldItemType, EntitySimpleBaseType valueOfFieldStateType) { string itemValue = valueOfFieldItemType.Value; string stateValue = valueOfFieldStateType.Value; if ((itemValue == null) && (stateValue == null)) { return(true); } // If one of objects to compare is null and another one is not null the compare result must be false. if (this.IsOneOfTheseObjectsNullAndAnotherOneNotNull(itemValue, stateValue) && string.IsNullOrEmpty(valueOfFieldStateType.var_ref) && valueOfFieldStateType.datatype != SimpleDatatypeEnumeration.@string) { return(false); } var value = valueOfFieldStateType.Value; if (IsThereDefinedVariable(valueOfFieldStateType)) { value = ProcessVariableById(valueOfFieldStateType.var_ref); } IOvalComparator comparator = new OvalComparatorFactory().GetComparator(valueOfFieldStateType.datatype); string firstElement = itemValue; string secondElement = value; return(comparator.Compare(firstElement, secondElement, valueOfFieldStateType.operation)); }
private IEnumerable <String> ProcessOperationForIdEntity( EntityObjectIntType idEntity, IEnumerable <string> currentIdValues) { if (idEntity.operation.Equals(OperationEnumeration.equals)) { return(currentIdValues); } var result = new List <String>(); var allMetabaseIDs = this.ObjectCollector.GetAllMetabaseIDs(); var ovalComparator = new OvalComparatorFactory().GetComparator(idEntity.datatype); foreach (var idValue in currentIdValues) { foreach (var metabaseId in allMetabaseIDs) { if (ovalComparator.Compare(metabaseId, idValue, idEntity.operation)) { result.Add(metabaseId); } } } return(result); }
private IEnumerable <ItemType> ProcessOperationsInstance(IEnumerable <ItemType> itemTypes, textfilecontent54_object textFileContent) { var result = new List <ItemType>(); var instanceEntity = (EntityObjectIntType)textFileContent.GetItemValue(textfilecontent54_ItemsChoices.instance); var comparator = new OvalComparatorFactory().GetComparator(instanceEntity.datatype); foreach (var itemType in itemTypes) { if (itemType.status == StatusEnumeration.exists) { var textFileContentItem = (textfilecontent_item)itemType; if (comparator.Compare(textFileContentItem.instance.Value, instanceEntity.Value, instanceEntity.operation)) { result.Add(itemType); } } else { result.Add(itemType); } } return(result); }
private IEnumerable <string> EvaluateOperationsDifferentsOfPatternMatch(OperationEnumeration operation, string entityValue, IEnumerable <string> valuesToMatch) { var comparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); var values = new List <string>(); foreach (string valueToMatch in valuesToMatch) { if (comparator.Compare(entityValue, valueToMatch, operation)) { values.Add(valueToMatch); } } return(values); }
private IEnumerable <string> ApplyRestriction(RestrictionType restriction, string value, Common.SimpleDatatypeEnumeration datatypeEnumeration, string restrictionHint) { List <string> messages = new List <string>(); IOvalComparator comparator = new OvalComparatorFactory().GetComparator(datatypeEnumeration); if (!comparator.Compare(value, restriction.Value, restriction.operation)) { StringBuilder sb = new StringBuilder(); sb.AppendLine(restrictionHint); sb.AppendLine(restriction.GetRestrictionMessage()); messages.Add(sb.ToString()); } return(messages); }
private IEnumerable <string> EvaluateOperation(string value, IEnumerable <string> valuesToMatch, OperationEnumeration operation) { IOvalComparator comparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); List <string> values = new List <string>(); foreach (string valueToMatch in valuesToMatch) { if (comparator.Compare(value, valueToMatch, operation)) { values.Add(value); } } return(values); }
private IList <String> processOperation(string[] allGroupSIDs, string entityValue, OperationEnumeration operation) { var comparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); var processingResult = new List <String>(); foreach (var groupSID in allGroupSIDs) { if (comparator.Compare(groupSID, entityValue, operation)) { processingResult.Add(groupSID); } } return(processingResult); }
private IList <string> ProcessOperationDifferentOfEquals(OperationEnumeration operation, String entityValue) { var allSecurityPrinciples = this.getAllSecurityPrinciples(); var comparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); var processingResult = new List <String>(); foreach (var securityPrinciple in allSecurityPrinciples) { if (comparator.Compare(securityPrinciple, entityValue, operation)) { processingResult.Add(securityPrinciple); } } return(processingResult); }
private IEnumerable <OVAL.SystemCharacteristics.ItemType> ProcessEntityOperation(String entityValue, EntityObjectStringType entity) { var allTargetProcesses = this.ProcessCollector.GetProcessInfo(); var processResult = new List <OVAL.SystemCharacteristics.ItemType>(); var comparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); foreach (var targetProcess in allTargetProcesses) { if (comparator.Compare(targetProcess.Command, entityValue, entity.operation)) { var newProcessItem = CreateProcessItem(targetProcess); processResult.Add(newProcessItem); } } return(processResult); }
private bool Compare(EntityItemSimpleBaseType valueOfFieldItemType, EntityItemSimpleBaseType valueOfFieldOtherItemType) { if ((valueOfFieldItemType.Value == null) && (valueOfFieldOtherItemType.Value == null)) { return(true); } if (valueOfFieldItemType.status != valueOfFieldOtherItemType.status) { return(false); } IOvalComparator comparator = new OvalComparatorFactory().GetComparator(valueOfFieldItemType.datatype); return(comparator.Compare(valueOfFieldItemType.Value, valueOfFieldOtherItemType.Value, OperationEnumeration.equals)); }
private bool ProcessComparisionForComplexEntityType( EntityItemRecordType[] valueOfFieldItemType, EntityStateRecordType valueOfFieldStateType) { if (valueOfFieldItemType == null) { return(false); } var recordFieldsOfState = valueOfFieldStateType.field; var recordFieldsOfItem = valueOfFieldItemType.First().field; foreach (var stateField in recordFieldsOfState) { var equivalentItemField = recordFieldsOfItem.Where( item => item.name.Equals(stateField.name, StringComparison.InvariantCultureIgnoreCase)) .SingleOrDefault(); if (equivalentItemField == null) { return(false); } var stateEntityFieldValue = stateField.Value; if (!String.IsNullOrWhiteSpace(stateField.var_ref)) { stateEntityFieldValue = ProcessVariableById(stateField.var_ref); } var ovalComparator = new OvalComparatorFactory().GetComparator(stateField.datatype); if (!ovalComparator.Compare(equivalentItemField.Value, stateEntityFieldValue, stateField.operation)) { return(false); } } return(true); }
public virtual IEnumerable <ItemType> CollectItems(string filepath, string trusteeSidPattern, OperationEnumeration operation) { var cachedItems = this.TryToGetCollectedItemsFromCache(filepath, trusteeSidPattern); if (cachedItems != null) { return(cachedItems.Select(item => CloneItemType(item))); } var invokeMethodInfo = CreateInvokeMethodInfo(filepath); object managementACEs = null; try { managementACEs = WmiProvider.InvokeMethodByWmiPath(invokeMethodInfo); } catch (InvalidInvokeMethodException) { var notExistItem = CreateItemToCollect(filepath, trusteeSidPattern, StatusEnumeration.doesnotexist); return(new ItemType[] { notExistItem }); } var allUsers = DaclDisassembler.GetAllSecurityDescriptorsFromManagementObject(managementACEs).ToList(); var usersDACLs = new Dictionary <string, List <WMIWinACE> >(); foreach (var userACL in allUsers) { var sid = userACL.Trustee.SIDString; if (usersDACLs.ContainsKey(sid)) { usersDACLs[sid].Add(userACL); } else { usersDACLs.Add(sid, new WMIWinACE[] { userACL }.ToList()); } } var ovalComparator = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); var collectedItems = new List <fileeffectiverights_item>(); foreach (var dacl in usersDACLs) { var trusteeSID = dacl.Key; var userDACLs = dacl.Value; if (ovalComparator.Compare(trusteeSID, trusteeSidPattern, operation)) { cachedItems = this.TryToGetCollectedItemsFromCache(filepath, trusteeSID); if (cachedItems != null) { collectedItems.AddRange(cachedItems.Select(item => CloneItemType(item))); continue; } var newCollectedItem = this.CreateItemToCollect(filepath, trusteeSID); FillCollectedItem(newCollectedItem, userDACLs); collectedItems.Add(newCollectedItem); this.AddToFlatCache(filepath, trusteeSID, newCollectedItem); } } if (collectedItems.Count == 0) { var newNotExistsItem = CreateItemToCollect(filepath, trusteeSidPattern, StatusEnumeration.doesnotexist); collectedItems.Add(newNotExistsItem); this.AddToFlatCache(filepath, trusteeSidPattern, newNotExistsItem); } this.AddToCache(filepath, trusteeSidPattern, collectedItems); return(collectedItems); }
private bool Compare(string foundUserSID, string expectedUserSID, OperationEnumeration operation) { var ovalCompartor = new OvalComparatorFactory().GetComparator(SimpleDatatypeEnumeration.@string); return(ovalCompartor.Compare(foundUserSID, expectedUserSID, operation)); }