public override bool Met(MVEntry mventry, CSEntry csentry)
{
if (!mventry[this.MVAttributeStartDate].IsPresent)
{
Tracer.TraceInformation("Condition failed (Reason: MVAttributeStartDate {0} attribute value is not present) / {0}", this.MVAttributeStartDate, this.Description);
return(false);
}
if (!mventry[this.MVAttributeEndDate].IsPresent)
{
Tracer.TraceInformation("Condition failed (Reason: MVAttributeEndDate {0} attribute value is not present) / {0}", this.MVAttributeEndDate, this.Description);
return(false);
}
DateTime startDate;
DateTime endDate;
if (!DateTime.TryParse(mventry[this.MVAttributeStartDate].StringValue, out startDate))
{
Tracer.TraceWarning("unable-to-parse-start-mvvalue-to-datetime {0}", mventry[this.MVAttributeStartDate].StringValue);
return(false);
}
if (!DateTime.TryParse(mventry[this.MVAttributeEndDate].StringValue, out endDate))
{
Tracer.TraceWarning("unable-to-parse-end-mvvalue-to-datetime {0}", mventry[this.MVAttributeEndDate].StringValue);
return(false);
}
DateTime now = DateTime.Now;
bool returnValue = (startDate < now) && (now < endDate);
Tracer.TraceInformation("compare-dates now: {0}, start: {1}, end: {2}, is-between: {3}", now, startDate, endDate, returnValue);
return(returnValue);
}
private void CreateConnector(ConnectedMA ma, MVEntry mventry, Rule rule)
{
Tracer.TraceInformation("enter-createconnector");
try
{
Tracer.TraceInformation("create-connector: MV: '{0}', MA: '{1}'", mventry.ObjectID, ma.Name);
IList <string> additionalObjectClasses = this.GetAdditionalObjectClasses(mventry, rule);
CSEntry csentry;
if (additionalObjectClasses.Count > 0)
{
csentry = ma.Connectors.StartNewConnector(rule.TargetObject, additionalObjectClasses.ToArray());
}
else
{
csentry = ma.Connectors.StartNewConnector(rule.TargetObject);
}
this.SetupInitialValues(ma, csentry, mventry, rule);
csentry.CommitNewConnector();
}
catch (Exception ex)
{
Tracer.TraceError("error {0}", ex.GetBaseException());
throw;
}
finally
{
Tracer.TraceInformation("exit-createconnector");
}
}
void RevertImpersonation()
{
if (!ShouldImpersonate())
{
return;
}
Tracer.Enter("revertimpersonation");
try
{
Tracer.TraceInformation("closing-impersonation-context");
m_ImpersonationContext.Undo();
Tracer.TraceInformation("closing-impersonation-tokenhandle {0}", impersonationToken);
NativeMethods.CloseHandle(impersonationToken);
Tracer.TraceInformation("closing-impersonation-duplicated-tokenhandle {0}", tokenDuplicate);
NativeMethods.CloseHandle(tokenDuplicate);
}
catch (Exception ex)
{
Tracer.TraceError("revertimpersonation", ex);
throw;
}
finally
{
Tracer.Exit("revertimpersonation");
}
}
private void SetupInitialValues(ConnectedMA ma, CSEntry csentry, MVEntry mventry, Rule connectorRule)
{
Tracer.TraceInformation("enter-setupinitialvalues");
try
{
if (connectorRule.Helpers != null)
{
Tracer.TraceInformation("generating-helper-values");
foreach (HelperValue helper in connectorRule.Helpers)
{
helper.Generate();
}
}
foreach (AttributeFlowBase attributeBase in connectorRule.InitialFlows)
{
attributeBase.Generate(ma, csentry, mventry, connectorRule);
}
}
catch (Exception ex)
{
Tracer.TraceError("error {0}", ex.GetBaseException());
throw;
}
finally
{
Tracer.TraceInformation("exit-setupinitialvalues");
}
}
public IEnumerable <AttributeDefinition> GetSchema(string TableName)
{
Tracer.Enter("getschema");
try
{
string query = string.Format("select top 1 * from {0}", TableName);
Tracer.TraceInformation("run-query '{0}'", query);
SqlCommand command = new SqlCommand(query, con);
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
for (int n = 0; n < reader.FieldCount; n++)
{
Tracer.TraceInformation("return-column: name: {0}, type: {1}", reader.GetName(n), reader.GetDataTypeName(n));
yield return(new AttributeDefinition(reader.GetName(n), reader.GetDataTypeName(n)));
}
}
}
}
finally
{
Tracer.Exit("getschema");
}
}
public override bool Met(MVEntry mventry, CSEntry csentry)
{
if (!mventry[this.MVAttribute].IsPresent)
{
Tracer.TraceInformation("Condition failed (Reason: No metaverse value is present) {0}", this.Description);
return(false);
}
if (mventry[this.MVAttribute].Values?.Count > 0)
{
var cmpOptions = StringComparison.CurrentCulture;
if (!CaseSensitive)
{
cmpOptions = StringComparison.CurrentCultureIgnoreCase;
}
var entries = mventry[this.MVAttribute].Values.ToStringArray();
return(entries.Any(x => String.Equals(x, Pattern, cmpOptions)));
}
else
{
Tracer.TraceInformation("Condition failed (Reason: Metaverse multivalue contains no elements) {0}", this.Description);
return(false);
}
}
public override void Generate(ConnectedMA ma, CSEntry csentry, MVEntry mventry, Rule rule)
{
Tracer.TraceInformation("enter-attributeflowguid");
base.Generate(ma, csentry, mventry, rule);
try
{
Guid newGuid = Guid.NewGuid();
Tracer.TraceInformation("new-guid-'{0}'-to-'{1}'", newGuid.ToString(), this.Target);
if (this.Target.Equals("[DN]", StringComparison.OrdinalIgnoreCase))
{
csentry.DN = csentry.MA.CreateDN(newGuid.ToString());
}
else
{
csentry[this.Target].Value = newGuid.ToString();
}
}
catch (Exception ex)
{
Tracer.TraceError("error {0}", ex.GetBaseException());
throw;
}
finally
{
Tracer.TraceInformation("exit-attributeflowguid");
}
}
public void RunStoredProcedure(string query, IEnumerable <SqlParameter> parameters)
{
Tracer.Enter("runstoredprocedure");
try
{
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter param in parameters)
{
Tracer.TraceInformation("add-parameter name: {0}, value: '{1}'", param.ParameterName, param.SqlValue);
cmd.Parameters.Add(param);
}
Tracer.TraceInformation("run-storedprocedure {0}", query);
Tracer.TraceInformation("rows-affected {0:n0}", cmd.ExecuteNonQuery());
}
}
catch (Exception ex)
{
Tracer.TraceError("runstoredprocedure", ex);
}
finally
{
Tracer.Exit("runstoredprocedure");
}
}
public bool ExistRecord(object anchor)
{
Tracer.Enter("existrecord");
try
{
string query = string.Format("select {0} from {1} where [{0}] = @anchor;", Configuration.AnchorColumn, Configuration.TableNameSingle, Configuration.AnchorColumn);
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.Parameters.AddWithValue("@anchor", anchor);
Tracer.TraceInformation("run-query {0}", query);
object affectedRecords = (object)cmd.ExecuteScalar();
Tracer.TraceInformation("exists {0}", affectedRecords != null);
return(affectedRecords != null);
}
}
catch (Exception ex)
{
Tracer.TraceError("existrecord", ex);
}
finally
{
Tracer.Exit("existrecord");
}
return(false);
}
public PSObject InitializeSchemaVariables(Schema Schema)
{
if (Schema == null)
{
return(null);
}
schema = Schema;
schemaPSObject = new PSObject();
foreach (SchemaType type in schema.Types)
{
PSObject typeObj = new PSObject();
typeObj.Members.Add(new PSNoteProperty("ObjectType", type.Name));
typeObj.Members.Add(new PSNoteProperty("PossibleDNComponentsForProvisioning", type.PossibleDNComponentsForProvisioning));
PSObject attrObj = new PSObject();
foreach (SchemaAttribute attr in type.AnchorAttributes)
{
Tracer.TraceInformation("{0}-anchor-attribute {1} [{2}]", type.Name, attr.Name, attr.DataType);
attrObj.Members.Add(new PSNoteProperty(attr.Name, attr));
}
typeObj.Members.Add(new PSNoteProperty("Anchors", attrObj));
attrObj = new PSObject();
foreach (SchemaAttribute attr in type.Attributes)
{
Tracer.TraceInformation("{0}-attribute {1} [{2}]", type.Name, attr.Name, attr.DataType);
attrObj.Members.Add(new PSNoteProperty(attr.Name, attr));
}
typeObj.Members.Add(new PSNoteProperty("Attributes", attrObj));
// add to general schema object
schemaPSObject.Members.Add(new PSNoteProperty(type.Name, typeObj));
}
return(null);
}
bool ShouldImpersonate()
{
bool impersonate = !string.IsNullOrEmpty(impersonationUsername) && !string.IsNullOrEmpty(impersonationUserPassword);
Tracer.TraceInformation("should-impersonate '{0}'", impersonate);
return(impersonate);
}
AttributeType GetAttributeOverride(ObjectClass objectClass, AttributeDefinition ad, AttributeType attrType)
{
DatabaseColumn ov = objectClass.Overrides.FirstOrDefault(x => x.Name.Equals(ad.Name));
if (ov != null)
{
switch (ov.SchemaType)
{
case OverrideType.Binary:
attrType = AttributeType.Binary;
break;
case OverrideType.Boolean:
attrType = AttributeType.Boolean;
break;
case OverrideType.Integer:
attrType = AttributeType.Integer;
break;
case OverrideType.Reference:
attrType = AttributeType.Reference;
break;
case OverrideType.String:
attrType = AttributeType.String;
break;
default:
break;
}
Tracer.TraceInformation($"setting-override-type-for name: {ad.Name}, schema-type: {ad.AttributeType}, override-type: {ov.SchemaType}");
}
return(attrType);
}
void WhoAmI()
{
Tracer.Enter("show-identity");
try
{
using (WindowsIdentity currentIdentity = WindowsIdentity.GetCurrent())
{
Tracer.TraceInformation("identity-name: {0}", currentIdentity.Name);
Tracer.TraceInformation("identity-token: {0}", currentIdentity.Token);
Tracer.TraceInformation("identity-user-value: {0}", currentIdentity.User.Value);
if (currentIdentity.Actor != null)
{
Tracer.TraceInformation("identity-actor: {0}", currentIdentity.Actor.Name);
Tracer.TraceInformation("identity-actor-auth-type: {0}", currentIdentity.Actor.AuthenticationType);
}
if (currentIdentity.Groups != null)
{
foreach (IdentityReference group in currentIdentity.Groups)
{
NTAccount account = group.Translate(typeof(NTAccount)) as NTAccount;
Tracer.TraceInformation("group-membership {0}", account.Value);
}
}
}
}
catch (Exception ex)
{
Tracer.TraceError("error-showing-current-identity", ex);
throw;
}
finally
{
Tracer.Exit("show-identity");
}
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
Tracer.Enter("closeimportconnectionresults");
try
{
CloseRunspace();
CloseImportConnectionResults cicr = new CloseImportConnectionResults();
Tracer.TraceInformation("custom-data {0}", importRunStep.CustomData);
Tracer.TraceInformation("close-reason {0}", importRunStep.Reason);
if (importRunStep.Reason == CloseReason.Normal)
{
cicr.CustomData = importRunStep.CustomData;
}
Dispose();
return(cicr);
}
catch (Exception ex)
{
Tracer.TraceError("closeimportconnection", ex);
throw;
}
finally
{
Tracer.Exit("closeimportconnectionresults");
}
}
public void RemoveAllMultiValues(object anchor, string attributeName, bool softDelete)
{
Tracer.Enter("removeallmultivalues");
try
{
string query = null;
if (softDelete)
{
query = string.Format("update {0} set [{1}] = 1 where ([{2}] = @anchor and [{3}] is not null and [{1}] <> 1)", Configuration.TableNameMulti, Configuration.DeletedColumn, Configuration.BackReferenceColumn, attributeName);
}
else
{
query = string.Format("delete from {0} where ([{1}] = @anchor and [{2}] is not null)", Configuration.TableNameMulti, Configuration.BackReferenceColumn, attributeName);
}
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.Parameters.AddWithValue("@anchor", anchor);
Tracer.TraceInformation("run-query {0}", query);
Tracer.TraceInformation("rows-affected {0:n0}", cmd.ExecuteNonQuery());
}
}
catch (Exception ex)
{
Tracer.TraceError("removeallmultivalues", ex);
}
finally
{
Tracer.Exit("removeallmultivalues");
}
}
public void LoadExternalAssembly()
{
if (string.IsNullOrEmpty(this.FilenameFull))
{
return;
}
Tracer.TraceInformation("enter-loadexternalassembly");
try
{
{
Tracer.TraceInformation("loading-loadexternalassembly {0}", Path.Combine(Utils.ExtensionsDirectory, this.FilenameFull));
this.Assembly = Assembly.LoadFile(FilenameFull);
Type[] types = Assembly.GetExportedTypes();
Type type = types.FirstOrDefault(u => u.GetInterface("Microsoft.MetadirectoryServices.IMVSynchronization") != null);
if (type != null)
{
instance = Activator.CreateInstance(type) as IMVSynchronization;
}
else
{
Tracer.TraceError("interface-not-implemented {0}", "Microsoft.MetadirectoryServices.IMVSynchronization");
throw new NotImplementedException("interface-not-implemented");
}
}
}
catch (Exception ex)
{
Tracer.TraceError("loadexternalassembly {0}", ex.GetBaseException());
throw;
}
finally
{
Tracer.TraceInformation("exit-loadexternalassembly");
}
}
void IMAExtensible2CallExport.OpenExportConnection(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenExportConnectionRunStep exportRunStep)
{
Tracer.IndentLevel = 0;
Tracer.Enter("openexportconnection");
Tracer.Indent();
try
{
InitializeConfigParameters(configParameters);
OpenRunspace();
schema = types;
exportType = exportRunStep.ExportType;
Tracer.TraceInformation("export-type '{0}'", exportType);
exportBatchSize = exportRunStep.BatchSize;
Tracer.TraceInformation("export-batch-size '{0}'", exportBatchSize);
}
catch (Exception ex)
{
Tracer.TraceError("openexportconnection", ex);
throw new TerminateRunException(ex.Message);
}
finally
{
Tracer.Unindent();
Tracer.Exit("openexportconnection");
}
}
public DataSet ReadObjects(List <object> anchors)
{
Tracer.Enter("readobjects");
DataSet ds = new DataSet();
try
{
string singleanchor = Configuration.AnchorColumn;
string multivalueanchorref = Configuration.BackReferenceColumn;
DataTable single = new DataTable(Configuration.TableNameSingle);
DataTable multi = Configuration.HasMultivalueTable ? new DataTable(Configuration.TableNameMulti) : null;
ds.Tables.Add(single);
StringBuilder anchorList = new StringBuilder();
for (int i = 0; i < anchors.Count; i++)
{
if (i > 0)
{
anchorList.Append(",");
}
anchorList.AppendFormat("'{0}'", anchors[i]);
}
StringBuilder query = new StringBuilder();
query.AppendFormat("select * from {0} where [{1}] in ({2});", Configuration.TableNameSingle, singleanchor, anchorList);
if (Configuration.HasMultivalueTable)
{
query.AppendFormat("select * from {0} where [{1}] in ({2});", Configuration.TableNameMulti, multivalueanchorref, anchorList);
ds.Tables.Add(multi);
}
Tracer.TraceInformation("run-query '{0}'", query.ToString());
using (SqlCommand cmd = new SqlCommand(query.ToString(), con))
{
using (SqlDataReader dr = cmd.ExecuteReader())
{
if (Configuration.HasMultivalueTable)
{
ds.Load(dr, LoadOption.OverwriteChanges, single, multi);
DataRelation relCustOrder = new DataRelation("mv", single.Columns[singleanchor], multi.Columns[multivalueanchorref]);
ds.Relations.Add(relCustOrder);
}
else
{
ds.Load(dr, LoadOption.OverwriteChanges, single);
}
}
}
}
catch (Exception ex)
{
Tracer.TraceError("readobjects {0}", ex.Message);
throw;
}
finally
{
Tracer.Exit("readobjects");
}
return(ds);
}
public static void Exit(string entryPoint)
{
Process currentProc = Process.GetCurrentProcess();
Tracer.TraceInformation("memory-usage {0:n0}Kb, private memory {1:n0}Kb", GC.GetTotalMemory(true) / 1024, currentProc.PrivateMemorySize64 / 1024);
Unindent();
TraceInformation("exit {0}", entryPoint);
}
void SetupImpersonationToken()
{
Tracer.Enter("setupimpersonationtoken");
try
{
if (!ShouldImpersonate())
{
Tracer.TraceInformation("impersonation-not-configured-running-as-sync-service-account");
WhoAmI();
return;
}
WindowsIdentity m_ImpersonatedUser;
Tracer.TraceInformation("user-before-impersonation: {0}", WindowsIdentity.GetCurrent(TokenAccessLevels.MaximumAllowed).Name);
//bool success = NativeMethods.LogonUser(impersonationUsername, impersonationUserDomain, impersonationUserPassword, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, out impersonationToken);
bool success = NativeMethods.LogonUser(impersonationUsername, impersonationUserDomain, impersonationUserPassword, (int)LogonType.LOGON32_LOGON_NETWORK_CLEARTEXT, (int)LogonProvider.LOGON32_PROVIDER_WINNT50, out impersonationToken);
if (!success)
{
SecurityException ex = new SecurityException(string.Format("failed-to-impersonate: domain: '{0}', username: '******', password: **secret***", impersonationUserDomain, impersonationUsername));
Tracer.TraceError(ex.ToString());
throw ex;
}
else
{
Tracer.TraceInformation("succeeded-in-impersonating: domain: '{0}', username: '******', password: **secret***", impersonationUserDomain, impersonationUsername);
if (NativeMethods.DuplicateToken(impersonationToken, (int)ImpersonationLevel.SecurityImpersonation, ref tokenDuplicate) != 0)
{
m_ImpersonatedUser = new WindowsIdentity(tokenDuplicate);
m_ImpersonationContext = m_ImpersonatedUser.Impersonate();
Tracer.TraceInformation("succeeded-in-duplicating-impersonation-token");
if (m_ImpersonationContext != null)
{
Tracer.TraceInformation("user-after-impersonation: {0}", WindowsIdentity.GetCurrent(TokenAccessLevels.MaximumAllowed).Name);
WhoAmI();
}
else
{
throw new Exception("impersonation-context-is-null");
}
}
else
{
throw new Exception("could-not-duplicate-impersonation-token");
}
}
}
catch (Exception ex)
{
Tracer.TraceError("setupimpersonationtoken", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("setupimpersonationtoken");
}
}
PSCredential GetSecureCredentials()
{
if (string.IsNullOrEmpty(Username) || (SecureStringPassword == null))
{
Tracer.TraceInformation("username-or-password-empty returning-null-pscredentials");
return(null);
}
return(new PSCredential(Username, SecureStringPassword));
}
PSCredential GetSecureClientCredentials()
{
if (string.IsNullOrEmpty(ClientId) || (SecureStringSecret == null))
{
Tracer.TraceInformation("clientid-or-secret-empty returning-null-pscredentials");
return(null);
}
return(new PSCredential(ClientId, SecureStringSecret));
}
public void GetObjectClasses()
{
methods.OpenConnection();
foreach (string str in methods.GetObjectClasses())
{
Tracer.TraceInformation("got-objectclass {0}", str);
}
methods.Dispose();
}
public override bool Met(MVEntry mventry, CSEntry csentry)
{
ConnectedMA MA = mventry.ConnectedMAs[this.ManagementAgentName];
if (MA.Connectors.Count.Equals(0))
{
Tracer.TraceInformation("Condition failed (Reason: Not connected to {0}) {1}", this.ManagementAgentName, this.Description);
return(false);
}
return(true);
}
public PowerShellManagementAgent()
{
Tracer.IndentLevel = 0;
Tracer.Enter("initialize");
Tracer.Indent();
try
{
Tracer.TraceInformation("memory-usage {0:n} Mb", GC.GetTotalMemory(true) / 102400);
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
Tracer.TraceInformation("psma-version {0}", version);
Tracer.TraceInformation("reading-registry-settings");
RegistryKey machineRegistry = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
RegistryKey mreRootKey = machineRegistry.OpenSubKey(@"SOFTWARE\Granfeldt\FIM\ManagementAgents\PowerShell", false);
if (mreRootKey != null)
{
Tracer.TraceInformation("adding-eventlog-listener-for name: {0}, source: {1}", EventLogName, EventLogSource);
EventLog evl = new EventLog(EventLogName);
evl.Log = EventLogName;
evl.Source = EventLogSource;
EventLogTraceListener eventLog = new EventLogTraceListener(EventLogSource);
eventLog.EventLog = evl;
EventTypeFilter filter = new EventTypeFilter(SourceLevels.Warning | SourceLevels.Error | SourceLevels.Critical);
eventLog.TraceOutputOptions = TraceOptions.Callstack;
eventLog.Filter = filter;
Tracer.Trace.Listeners.Add(eventLog);
if (!EventLog.SourceExists(EventLogSource))
{
Tracer.TraceInformation("creating-eventlog-source '{0}'", EventLogSource);
EventLog.CreateEventSource(EventLogSource, EventLogName);
}
string logFileValue = mreRootKey.GetValue("DebugLogFileName", null) as string;
if (logFileValue != null)
{
Tracer.TraceWarning("Logging to file is no longer supported. Please remove registrykey DebugLogFileName and use DebugView or similar instead to catch traces from this Management Agent");
}
}
}
catch (Exception ex)
{
Tracer.TraceError("could-not-initialize", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("initialize");
}
}
public override bool Met(MVEntry mventry, CSEntry csentry)
{
if (mventry[this.MVAttribute].IsPresent)
{
if (mventry[this.MVAttribute].BooleanValue)
{
Tracer.TraceInformation("Condition failed (Reason: Boolean value is true) {0}", this.Description);
return(false);
}
}
return(true);
}
public override bool Met(MVEntry mventry, CSEntry csentry)
{
if (mventry[this.MVAttribute].IsPresent)
{
return(true);
}
else
{
Tracer.TraceInformation("Condition failed (Reason: Metaverse attribute value is not present) {0}", this.Description);
return(false);
}
}
public override bool Met(MVEntry mventry, CSEntry csentry)
{
if (mventry[this.MVAttribute].IsPresent)
{
if (Regex.IsMatch(mventry[this.MVAttribute].Value, this.Pattern, RegexOptions.IgnoreCase))
{
Tracer.TraceInformation("Condition failed (Reason: RegEx match) {0}", this.Description);
return(false);
}
}
return(true); // value not present effectively means not-match
}
string CSValueAsString(object Value, AttributeType DataType)
{
Tracer.TraceInformation("CSValueAsString {0}, {1}", Value == null ? "(null)" : Value.GetType().ToString(), DataType);
switch (DataType)
{
case AttributeType.Binary:
return(new Guid((Byte[])Value).ToString());
default:
return(Value.ToString());
}
}
private bool AreDNsEqual(ReferenceValue dn1, ReferenceValue dn2, ManagementAgent ma, bool strictCompare)
{
if (strictCompare)
{
Tracer.TraceInformation("performing-strict-DN-comparison");
return(dn1.ToString() == dn2.ToString());
}
else
{
Tracer.TraceInformation("performing-RFC-compliant-DN-comparison");
return(dn1.Equals(dn2));
}
}
