public override void ProcessRecord()
{
if (!this.dataObject.Force && !base.ShouldContinue(Strings.PromptToOverwriteDlpPoliciesOnImport))
{
return;
}
ADRuleStorageManager adruleStorageManager = new ADRuleStorageManager(Utils.RuleCollectionNameFromRole(), base.DataSession);
adruleStorageManager.LoadRuleCollection();
foreach (TransportRuleHandle transportRuleHandle in adruleStorageManager.GetRuleHandles())
{
Guid guid;
if (transportRuleHandle.Rule.TryGetDlpPolicyId(out guid))
{
base.DataSession.Delete(transportRuleHandle.AdRule);
}
}
DlpUtils.GetInstalledTenantDlpPolicies(base.DataSession).ToList <ADComplianceProgram>().ForEach(new Action <ADComplianceProgram>(base.DataSession.Delete));
List <DlpPolicyMetaData> list = DlpUtils.LoadDlpPolicyInstances(this.dataObject.FileData).ToList <DlpPolicyMetaData>();
foreach (DlpPolicyMetaData dlpPolicy in list)
{
IEnumerable <PSObject> enumerable;
DlpUtils.AddTenantDlpPolicy(base.DataSession, dlpPolicy, Utils.GetOrganizationParameterValue(this.dataObject.Fields), new CmdletRunner(DlpPolicyTemplateMetaData.AllowedCommands, DlpPolicyTemplateMetaData.RequiredParams, null), out enumerable);
}
}
internal void ValidateDlpPolicyName()
{
if (DlpUtils.GetInstalledTenantDlpPolicies(base.DataSession, this.dlpPolicy.Name).Any <ADComplianceProgram>())
{
this.taskObject.WriteError(new ArgumentException(Strings.ErrorDlpPolicyAlreadyInstalled(this.dlpPolicy.Name)), ErrorCategory.InvalidArgument, "Name");
}
}
public override void Validate()
{
if (this.dataObject.FileData == null)
{
this.dataObject.WriteError(new ArgumentException(Strings.ImportDlpPolicyFileDataIsNull), ErrorCategory.InvalidArgument, "FileData");
}
try
{
this.templates = DlpUtils.LoadDlpPolicyTemplates(this.dataObject.FileData);
}
catch (Exception ex)
{
if (!this.IsKnownException(ex))
{
throw;
}
this.dataObject.WriteError(ex, ErrorCategory.InvalidOperation, null);
}
using (IEnumerator <ADComplianceProgram> enumerator = DlpUtils.GetOutOfBoxDlpTemplates(base.DataSession).GetEnumerator())
{
while (enumerator.MoveNext())
{
ADComplianceProgram dlpPolicyTemplate = enumerator.Current;
if (this.templates.Any((DlpPolicyTemplateMetaData a) => a.Name == dlpPolicyTemplate.Name))
{
this.dataObject.WriteError(new ArgumentException(Strings.ErrorDlpPolicyTemplateAlreadyInstalled(dlpPolicyTemplate.Name)), ErrorCategory.InvalidArgument, "FileData");
}
}
}
}
internal static IEnumerable <Microsoft.Exchange.MessagingPolicies.Rules.Tasks.Rule> GetTransportRules(IConfigDataProvider dataSession, Func <Microsoft.Exchange.MessagingPolicies.Rules.Tasks.Rule, bool> selector)
{
ADRuleStorageManager adruleStorageManager;
IEnumerable <TransportRuleHandle> transportRuleHandles = DlpUtils.GetTransportRuleHandles(dataSession, out adruleStorageManager);
IEnumerable <Microsoft.Exchange.MessagingPolicies.Rules.Tasks.Rule> source = from ruleHandle in transportRuleHandles
select Microsoft.Exchange.MessagingPolicies.Rules.Tasks.Rule.CreateFromInternalRule(TransportRulePredicate.GetAvailablePredicateMappings(), TransportRuleAction.GetAvailableActionMappings(), ruleHandle.Rule, ruleHandle.AdRule.Priority, ruleHandle.AdRule);
return(source.Where(selector));
}
private DlpPolicyTemplateMetaData LoadDlpPolicyFromInstalledTemplate()
{
DlpPolicyTemplateMetaData dlpPolicyTemplateMetaData = DlpUtils.LoadOutOfBoxDlpTemplate(this.taskObject.DomainController, this.taskObject.Template);
if (dlpPolicyTemplateMetaData == null)
{
this.taskObject.WriteError(new ArgumentException(Strings.ErrorDlpPolicyTemplateNotFound(this.taskObject.Template)), ErrorCategory.InvalidArgument, "Template");
}
return(dlpPolicyTemplateMetaData);
}
internal static DlpPolicyTemplateMetaData LoadOutOfBoxDlpTemplate(Fqdn domainController, string templateName)
{
IConfigDataProvider dataSession = DlpUtils.CreateOrgSession(domainController);
ADComplianceProgram adcomplianceProgram = DlpUtils.GetOutOfBoxDlpTemplates(dataSession, templateName).FirstOrDefault <ADComplianceProgram>();
if (adcomplianceProgram != null)
{
return(DlpPolicyParser.ParseDlpPolicyTemplate(adcomplianceProgram.TransportRulesXml));
}
return(null);
}
public static List <string> GetEtrsForDlpPolicy(Guid dlpGuid, IConfigDataProvider dataSession)
{
ADRuleStorageManager adruleStorageManager;
IEnumerable <TransportRuleHandle> transportRuleHandles = DlpUtils.GetTransportRuleHandles(dataSession, out adruleStorageManager);
IEnumerable <Microsoft.Exchange.MessagingPolicies.Rules.Tasks.Rule> source = from ruleHandle in transportRuleHandles
select Microsoft.Exchange.MessagingPolicies.Rules.Tasks.Rule.CreateFromInternalRule(TransportRulePredicate.GetAvailablePredicateMappings(), TransportRuleAction.GetAvailableActionMappings(), ruleHandle.Rule, ruleHandle.AdRule.Priority, ruleHandle.AdRule);
return((from rule in source
where rule.DlpPolicyId == dlpGuid
select rule.ToCmdlet()).ToList <string>());
}
public override void ProcessRecord()
{
try
{
DlpUtils.DeleteEtrsByDlpPolicy(this.taskObject.GetDataObject().ImmutableId, base.DataSession);
}
catch (ParserException ex)
{
this.taskObject.WriteError(new ArgumentException(Strings.RemoveDlpPolicyCorruptRule(this.taskObject.Identity.ToString(), ex.Message)), ErrorCategory.ParserError, this.taskObject.Identity);
}
base.DataSession.Delete(this.taskObject.GetDataObject());
}
internal DlpPolicyTemplateMetaData LoadDlpPolicyFromCustomTemplateData()
{
try
{
return(DlpUtils.LoadDlpPolicyTemplates(this.taskObject.TemplateData).FirstOrDefault <DlpPolicyTemplateMetaData>());
}
catch (Exception exception)
{
this.WriteParameterErrorIfExceptionOccurred(exception, "TemplateData");
}
return(null);
}
public static void SaveOutOfBoxDlpTemplates(IConfigDataProvider dataSession, IEnumerable <DlpPolicyTemplateMetaData> dlpTemplates)
{
ADComplianceProgramCollection dlpPolicyCollection = DlpUtils.GetDlpPolicyCollection(dataSession, DlpUtils.OutOfBoxDlpPoliciesCollectionName);
foreach (DlpPolicyTemplateMetaData dlpPolicyTemplateMetaData in dlpTemplates)
{
ADComplianceProgram adcomplianceProgram = dlpPolicyTemplateMetaData.ToAdObject();
adcomplianceProgram.OrganizationId = dlpPolicyCollection.OrganizationId;
adcomplianceProgram.SetId(dlpPolicyCollection.Id.GetChildId(dlpPolicyTemplateMetaData.Name));
dataSession.Save(adcomplianceProgram);
}
}
public override void Validate()
{
if (this.taskObject.Identity == null)
{
this.taskObject.WriteError(new ArgumentException(Strings.ErrorInvalidDlpPolicyTemplateIdentity, RemoveDlpPolicyImpl.Identity), ErrorCategory.InvalidArgument, this.taskObject.Identity);
return;
}
if (!DlpUtils.GetOutOfBoxDlpTemplates(base.DataSession, this.taskObject.Identity.ToString()).Any <ADComplianceProgram>())
{
this.taskObject.WriteError(new ArgumentException(Strings.ErrorDlpPolicyTemplateIsNotInstalled(this.taskObject.Identity.ToString())), ErrorCategory.InvalidArgument, this.taskObject.Identity);
}
}
public override void ProcessRecord()
{
try
{
IEnumerable <PSObject> enumerable;
DlpUtils.AddTenantDlpPolicy(base.DataSession, this.dlpPolicy, Utils.GetOrganizationParameterValue(this.taskObject.Fields), new CmdletRunner(DlpPolicyTemplateMetaData.AllowedCommands, DlpPolicyTemplateMetaData.RequiredParams, null), out enumerable);
}
catch (DlpPolicyScriptExecutionException exception)
{
this.taskObject.WriteError(exception, ErrorCategory.InvalidArgument, null);
}
}
internal static ILookup <string, Microsoft.Exchange.MessagingPolicies.Rules.Rule> GetDataClassificationsInUse(IConfigDataProvider tenantSession, IEnumerable <string> dataClassificationIds, IEqualityComparer <string> dataClassificationIdComparer = null)
{
ArgumentValidator.ThrowIfNull("tenantSession", tenantSession);
ArgumentValidator.ThrowIfNull("dataClassificationIds", dataClassificationIds);
if (!dataClassificationIds.Any <string>())
{
return(Enumerable.Empty <Microsoft.Exchange.MessagingPolicies.Rules.Rule>().ToLookup((Microsoft.Exchange.MessagingPolicies.Rules.Rule rule) => null));
}
ADRuleStorageManager adruleStorageManager = new ADRuleStorageManager(Utils.RuleCollectionNameFromRole(), tenantSession);
adruleStorageManager.LoadRuleCollection();
return(DlpUtils.GetDataClassificationsReferencedByRuleCollection(adruleStorageManager.GetRuleCollection(), dataClassificationIds, dataClassificationIdComparer));
}
internal ADComplianceProgram ToAdObject()
{
return(new ADComplianceProgram
{
Name = this.Name,
Description = this.Description,
ImmutableId = this.ImmutableId,
Keywords = this.Keywords.ToArray(),
PublisherName = this.PublisherName,
State = DlpUtils.RuleStateToDlpState(this.State, this.Mode),
TransportRulesXml = new StreamReader(new MemoryStream(DlpPolicyParser.SerializeDlpPolicyInstance(this))).ReadToEnd(),
Version = this.Version
});
}
protected override void WriteResult <T>(IEnumerable <T> dataObjects)
{
IList <DlpPolicyMetaData> list = (from dataObject in (IEnumerable <ADComplianceProgram>) dataObjects
select DlpPolicyParser.ParseDlpPolicyInstance(dataObject.TransportRulesXml)).ToList <DlpPolicyMetaData>();
foreach (DlpPolicyMetaData dlpPolicyMetaData in list)
{
dlpPolicyMetaData.PolicyCommands = DlpUtils.GetEtrsForDlpPolicy(dlpPolicyMetaData.ImmutableId, base.DataSession);
}
this.WriteResult(new BinaryFileDataObject
{
FileData = DlpPolicyParser.SerializeDlpPolicyInstances(list)
});
}
public static IEnumerable <ADComplianceProgram> GetOutOfBoxDlpTemplates(IConfigDataProvider dataSession, string name)
{
Guid guid;
QueryFilter filter;
if (Guid.TryParse(name, out guid))
{
filter = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Guid, guid);
}
else
{
filter = new TextFilter(ADObjectSchema.Name, name, MatchOptions.FullString, MatchFlags.Default);
}
return(DlpUtils.GetDlpPolicies(dataSession, DlpUtils.OutOfBoxDlpPoliciesCollectionName, filter));
}
public override void ProcessRecord()
{
try
{
DlpUtils.SaveOutOfBoxDlpTemplates(base.DataSession, this.templates);
}
catch (Exception ex)
{
if (!this.IsKnownException(ex))
{
throw;
}
this.dataObject.WriteError(ex, ErrorCategory.InvalidOperation, null);
}
}
public void WriteResult(IEnumerable <ADComplianceProgram> tenantDlpPolicyTemplates, GetDlpPolicy.WriteDelegate writeDelegate)
{
IEnumerable <ADComplianceProgram> outOfBoxDlpTemplates;
if (this.taskObject.Identity == null)
{
outOfBoxDlpTemplates = DlpUtils.GetOutOfBoxDlpTemplates(base.DataSession);
}
else
{
outOfBoxDlpTemplates = DlpUtils.GetOutOfBoxDlpTemplates(base.DataSession, this.taskObject.Identity.ToString());
}
foreach (ADComplianceProgram dlpPolicy in outOfBoxDlpTemplates)
{
writeDelegate(new DlpPolicyTemplate(dlpPolicy, this.taskObject.CommandRuntime.Host.CurrentCulture));
}
}
protected void UpdateRules(RuleState state, RuleMode mode)
{
bool flag = this.taskObject.TargetItem.IsModified(ADObjectSchema.Name);
ADRuleStorageManager adruleStorageManager;
IEnumerable <TransportRuleHandle> transportRuleHandles = DlpUtils.GetTransportRuleHandles(base.DataSession, out adruleStorageManager);
foreach (TransportRule transportRule in (from handle in transportRuleHandles
select handle.Rule).Where(new Func <TransportRule, bool>(this.RuleDlpPolicyIdMatches)))
{
transportRule.Enabled = state;
transportRule.Mode = mode;
if (flag)
{
transportRule.SetDlpPolicy(this.taskObject.TargetItem.ImmutableId, this.taskObject.TargetItem.Name);
}
}
adruleStorageManager.UpdateRuleHandles(transportRuleHandles);
}
public static void DeleteEtrsByDlpPolicy(Guid dlpGuid, IConfigDataProvider dataSession)
{
IEnumerable <TransportRule> enumerable;
string message;
if (!DlpUtils.TryGetTransportRules(dataSession, out enumerable, out message))
{
throw new InvalidOperationException(message);
}
foreach (TransportRule transportRule in enumerable)
{
TransportRule transportRule2 = (TransportRule)TransportRuleParser.Instance.GetRule(transportRule.Xml);
Guid guid;
if (transportRule2.TryGetDlpPolicyId(out guid) && guid.Equals(dlpGuid))
{
dataSession.Delete(transportRule);
}
}
}
public static IEnumerable <ADComplianceProgram> GetInstalledTenantDlpPolicies(IConfigDataProvider dataSession, string name)
{
Guid guid;
if (Guid.TryParse(name, out guid))
{
IList <ADComplianceProgram> list = (from x in DlpUtils.GetDlpPolicies(dataSession, DlpUtils.TenantDlpPoliciesCollectionName, null)
where x.ImmutableId.Equals(guid)
select x).ToList <ADComplianceProgram>();
if (!list.Any <ADComplianceProgram>())
{
list = DlpUtils.GetDlpPolicies(dataSession, DlpUtils.TenantDlpPoliciesCollectionName, new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Guid, guid)).ToList <ADComplianceProgram>();
}
if (list.Any <ADComplianceProgram>())
{
return(list);
}
}
return(DlpUtils.GetDlpPolicies(dataSession, DlpUtils.TenantDlpPoliciesCollectionName, new TextFilter(ADObjectSchema.Name, name, MatchOptions.FullString, MatchFlags.Default)));
}
public static void AddTenantDlpPolicy(IConfigDataProvider dataSession, DlpPolicyMetaData dlpPolicy, string organizationParameterValue, CmdletRunner cmdletRunner, out IEnumerable <PSObject> results)
{
results = null;
ADComplianceProgram adcomplianceProgram = dlpPolicy.ToAdObject();
ADComplianceProgramCollection dlpPolicyCollection = DlpUtils.GetDlpPolicyCollection(dataSession, DlpUtils.TenantDlpPoliciesCollectionName);
adcomplianceProgram.OrganizationId = dlpPolicyCollection.OrganizationId;
adcomplianceProgram.SetId(dlpPolicyCollection.Id.GetChildId(dlpPolicy.Name));
dataSession.Save(adcomplianceProgram);
IEnumerable <string> enumerable = Utils.AddOrganizationScopeToCmdlets(dlpPolicy.PolicyCommands, organizationParameterValue);
string domainController = null;
ADSessionSettings sessionSettings = null;
MessagingPoliciesSyncLogDataSession messagingPoliciesSyncLogDataSession = dataSession as MessagingPoliciesSyncLogDataSession;
if (messagingPoliciesSyncLogDataSession != null)
{
domainController = messagingPoliciesSyncLogDataSession.LastUsedDc;
sessionSettings = messagingPoliciesSyncLogDataSession.SessionSettings;
}
try
{
foreach (string cmdlet in enumerable)
{
cmdletRunner.RunCmdlet(cmdlet, true);
}
}
catch (ParseException e)
{
DlpUtils.HandleScriptExecutionError(adcomplianceProgram, DlpUtils.GetErrorHandlingDataSession(domainController, sessionSettings, dataSession), e);
}
catch (RuntimeException e2)
{
DlpUtils.HandleScriptExecutionError(adcomplianceProgram, DlpUtils.GetErrorHandlingDataSession(domainController, sessionSettings, dataSession), e2);
}
catch (CmdletExecutionException e3)
{
DlpUtils.HandleScriptExecutionError(adcomplianceProgram, DlpUtils.GetErrorHandlingDataSession(domainController, sessionSettings, dataSession), e3);
}
}
internal ADComplianceProgram ToAdObject()
{
string transportRulesXml;
using (MemoryStream memoryStream = new MemoryStream(DlpPolicyParser.SerializeDlpPolicyTemplate(this)))
{
StreamReader streamReader = new StreamReader(memoryStream);
transportRulesXml = streamReader.ReadToEnd();
}
ADComplianceProgram adcomplianceProgram = new ADComplianceProgram();
adcomplianceProgram.Name = DlpPolicyTemplateMetaData.GetLocalizedStringValue(this.LocalizedNames, null);
adcomplianceProgram.Description = DlpPolicyTemplateMetaData.GetLocalizedStringValue(this.LocalizedDescriptions, null);
adcomplianceProgram.ImmutableId = this.ImmutableId;
adcomplianceProgram.Keywords = (from keyword in this.LocalizedKeywords
select DlpPolicyTemplateMetaData.GetLocalizedStringValue(keyword, DlpPolicyTemplateMetaData.DefaultCulture)).ToArray <string>();
adcomplianceProgram.PublisherName = this.PublisherName;
adcomplianceProgram.State = DlpUtils.RuleStateToDlpState(this.State, this.Mode);
adcomplianceProgram.TransportRulesXml = transportRulesXml;
adcomplianceProgram.Version = this.Version;
return(adcomplianceProgram);
}
private static IEnumerable <ADComplianceProgram> GetDlpPolicies(IConfigDataProvider dataSession, string collectionName, QueryFilter filter)
{
ADComplianceProgramCollection dlpPolicyCollection = DlpUtils.GetDlpPolicyCollection(dataSession, collectionName);
return(dataSession.FindPaged <ADComplianceProgram>(filter, dlpPolicyCollection.Id, false, null, 0));
}
public static IEnumerable <ADComplianceProgram> GetInstalledTenantDlpPolicies(IConfigDataProvider dataSession)
{
return(DlpUtils.GetDlpPolicies(dataSession, DlpUtils.TenantDlpPoliciesCollectionName, null));
}
public override void ProcessRecord()
{
DlpUtils.DeleteOutOfBoxDlpPolicy(base.DataSession, this.taskObject.Identity.ToString());
}
public static IEnumerable <ADComplianceProgram> GetOutOfBoxDlpTemplates(IConfigDataProvider dataSession)
{
return(DlpUtils.GetDlpPolicies(dataSession, DlpUtils.OutOfBoxDlpPoliciesCollectionName, null));
}
public static void DeleteOutOfBoxDlpPolicies(IConfigDataProvider dataSession)
{
List <ADComplianceProgram> list = DlpUtils.GetOutOfBoxDlpTemplates(dataSession).ToList <ADComplianceProgram>();
list.ForEach(new Action <ADComplianceProgram>(dataSession.Delete));
}
public static void DeleteOutOfBoxDlpPolicy(IConfigDataProvider dataSession, string templateName)
{
ADComplianceProgram instance = DlpUtils.GetOutOfBoxDlpTemplates(dataSession, templateName).FirstOrDefault <ADComplianceProgram>();
dataSession.Delete(instance);
}
public override void ProcessRecord()
{
Tuple <RuleState, RuleMode> tuple = DlpUtils.DlpStateToRuleState(this.taskObject.TargetItem.State);
this.UpdateRules(tuple.Item1, tuple.Item2);
}
