{

#region Private members

private IOutputWriter outputWriter;

private Dictionary<string, object> settings;

#if !CORECLR

private CompositionContainer container;

#endif // !CORECLR

Dictionary<string, List<string>> validationResults = new Dictionary<string, List<string>>();

string[] includeRule;

string[] excludeRule;

string[] severity;

List<Regex> includeRegexList;

List<Regex> excludeRegexList;

bool suppressedOnly;

#if !PSV3

ModuleDependencyHandler moduleHandler;

#endif

#endregion

#region Singleton

private static object syncRoot = new Object();

private static ScriptAnalyzer instance;

public static ScriptAnalyzer Instance

{

get

{

if (instance == null)

{

lock (syncRoot)

{

if (instance == null)

instance = new ScriptAnalyzer();

}

}

return instance;

}

}

#endregion

#region Properties

#if CORECLR

public IEnumerable<IScriptRule> ScriptRules { get; private set; }

public IEnumerable<ITokenRule> TokenRules { get; private set; }

public IEnumerable<ILogger> Loggers { get; private set; }

public IEnumerable<IDSCResourceRule> DSCResourceRules { get; private set; }

#else

[ImportMany]

public IEnumerable<IScriptRule> ScriptRules { get; private set; }

[ImportMany]

public IEnumerable<ITokenRule> TokenRules { get; private set; }

[ImportMany]

public IEnumerable<ILogger> Loggers { get; private set; }

[ImportMany]

public IEnumerable<IDSCResourceRule> DSCResourceRules { get; private set; }

// Initializes via ImportMany

#endif // !CORECLR

internal List<ExternalRule> ExternalRules { get; set; }

#if !PSV3

public ModuleDependencyHandler ModuleHandler {

get

{

return moduleHandler;

}

internal set

{

moduleHandler = value;

}

}

#endif

#endregion

#region Methods

/// <summary>

/// Initialize : Initializes default rules, loggers and helper.

/// </summary>

internal void Initialize<TCmdlet>(

TCmdlet cmdlet,

string[] customizedRulePath = null,

string[] includeRuleNames = null,

string[] excludeRuleNames = null,

string[] severity = null,

bool includeDefaultRules = false,

bool suppressedOnly = false)

where TCmdlet : PSCmdlet, IOutputWriter

{

if (cmdlet == null)

{

throw new ArgumentNullException("cmdlet");

}

this.Initialize(

cmdlet,

cmdlet.SessionState.Path,

cmdlet.SessionState.InvokeCommand,

customizedRulePath,

includeRuleNames,

excludeRuleNames,

severity,

includeDefaultRules,

suppressedOnly);

}

/// <summary>

/// Initialize : Initializes default rules, loggers and helper.

/// </summary>

public void Initialize(

Runspace runspace,

IOutputWriter outputWriter,

string[] customizedRulePath = null,

string[] includeRuleNames = null,

string[] excludeRuleNames = null,

string[] severity = null,

bool includeDefaultRules = false,

bool suppressedOnly = false,

string profile = null)

{

if (runspace == null)

{

throw new ArgumentNullException("runspace");

}

//initialize helper

Helper.Instance = new Helper(

runspace.SessionStateProxy.InvokeCommand,

outputWriter);

Helper.Instance.Initialize();

this.Initialize(

outputWriter,

runspace.SessionStateProxy.Path,

runspace.SessionStateProxy.InvokeCommand,

customizedRulePath,

includeRuleNames,

excludeRuleNames,

severity,

includeDefaultRules,

suppressedOnly,

profile);

}

/// <summary>

/// clean up this instance, resetting all properties

/// </summary>

public void CleanUp()

{

includeRule = null;

excludeRule = null;

severity = null;

includeRegexList = null;

excludeRegexList = null;

suppressedOnly = false;

}

/// <summary>

/// Update includerules, excluderules, severity and rule arguments.

/// </summary>

/// <param name="settings">An object of type Settings</param>

public void UpdateSettings(Settings settings)

{

if (settings == null)

{

throw new ArgumentNullException(nameof(settings));

}

this.severity = (!settings.Severities.Any()) ? null : settings.Severities.ToArray();

this.includeRule = (!settings.IncludeRules.Any()) ? null : settings.IncludeRules.ToArray();

this.excludeRule = (!settings.ExcludeRules.Any()) ? null : settings.ExcludeRules.ToArray();

if (settings.RuleArguments != null)

{

Helper.Instance.SetRuleArguments(

settings.RuleArguments.ToDictionary(

kvp => kvp.Key,

kvp => kvp.Value as object,

StringComparer.OrdinalIgnoreCase));

}

}

internal bool ParseProfile(object profileObject, PathIntrinsics path, IOutputWriter writer)

{

// profile was not given

if (profileObject == null)

{

writer.WriteVerbose("No settings hashtable or file to consume");

return true;

}

if (!(profileObject is string || profileObject is Hashtable))

{

writer.WriteWarning("Settings parameter should be a hashtable or a filepath");

return false;

}

List<string> includeRuleList = new List<string>();

List<string> excludeRuleList = new List<string>();

List<string> severityList = new List<string>();

bool hasError = false;

Hashtable hashTableProfile = profileObject as Hashtable;

// checks whether we get a hashtable

if (hashTableProfile != null)

{

hasError = ParseProfileHashtable(hashTableProfile, path, writer, severityList, includeRuleList, excludeRuleList);

}

else

{

// checks whether we get a string instead

string profile = profileObject as string;

if (!String.IsNullOrWhiteSpace(profile))

{

hasError = ParseProfileString(profile, path, writer, severityList, includeRuleList, excludeRuleList);

}

}

if (hasError)

{

return false;

}

this.severity = (severityList.Count() == 0) ? null : severityList.ToArray();

this.includeRule = (includeRuleList.Count() == 0) ? null : includeRuleList.ToArray();

this.excludeRule = (excludeRuleList.Count() == 0) ? null : excludeRuleList.ToArray();

if (settings != null

&& settings.ContainsKey("Rules"))

{

var ruleArgs = settings["Rules"] as Dictionary<string, object>;

Helper.Instance.SetRuleArguments(ruleArgs);

}

return true;

}

private bool AddProfileItem(

string key,

List<string> values,

List<string> severityList,

List<string> includeRuleList,

List<string> excludeRuleList)

{

Debug.Assert(key != null);

Debug.Assert(values != null);

Debug.Assert(severityList != null);

Debug.Assert(includeRuleList != null);

Debug.Assert(excludeRuleList != null);

switch (key.ToLower())

{

case "severity":

severityList.AddRange(values);

break;

case "includerules":

includeRuleList.AddRange(values);

break;

case "excluderules":

excludeRuleList.AddRange(values);

break;

default:

return false;

}

return true;

}

private Dictionary<string, object> GetDictionaryFromHashTableAst(

HashtableAst hashTableAst,

IOutputWriter writer,

string profile,

out bool hasError)

{

hasError = false;

var output = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

foreach (var kvp in hashTableAst.KeyValuePairs)

{

var keyAst = kvp.Item1 as StringConstantExpressionAst;

if (keyAst == null)

{

// first item (the key) should be a string

writer.WriteError(

new ErrorRecord(

new InvalidDataException(

string.Format(

CultureInfo.CurrentCulture,

Strings.WrongKeyFormat,

kvp.Item1.Extent.StartLineNumber,

kvp.Item1.Extent.StartColumnNumber,

profile)),

Strings.ConfigurationKeyNotAString,

ErrorCategory.InvalidData,

profile));

hasError = true;

continue;

}

var key = keyAst.Value;

// parse the item2 as array

PipelineAst pipeAst = kvp.Item2 as PipelineAst;

List<string> rhsList = new List<string>();

if (pipeAst != null)

{

ExpressionAst pureExp = pipeAst.GetPureExpression();

if (pureExp is StringConstantExpressionAst)

{

rhsList.Add((pureExp as StringConstantExpressionAst).Value);

}

else if (pureExp is HashtableAst)

{

output[key] = GetDictionaryFromHashTableAst(

pureExp as HashtableAst,

writer,

profile,

out hasError);

continue;

}

else

{

ArrayLiteralAst arrayLitAst = pureExp as ArrayLiteralAst;

if (arrayLitAst == null && pureExp is ArrayExpressionAst)

{

ArrayExpressionAst arrayExp = pureExp as ArrayExpressionAst;

// Statements property is never null

if (arrayExp.SubExpression != null)

{

StatementAst stateAst = arrayExp.SubExpression.Statements.FirstOrDefault();

if (stateAst != null && stateAst is PipelineAst)

{

CommandBaseAst cmdBaseAst = (stateAst as PipelineAst).PipelineElements.FirstOrDefault();

if (cmdBaseAst != null && cmdBaseAst is CommandExpressionAst)

{

CommandExpressionAst cmdExpAst = cmdBaseAst as CommandExpressionAst;

if (cmdExpAst.Expression is StringConstantExpressionAst)

{

rhsList.Add((cmdExpAst.Expression as StringConstantExpressionAst).Value);

}

else

{

arrayLitAst = cmdExpAst.Expression as ArrayLiteralAst;

}

}

}

}

}

if (arrayLitAst != null)

{

foreach (var element in arrayLitAst.Elements)

{

// all the values in the array needs to be string

if (!(element is StringConstantExpressionAst))

{

outputWriter.WriteError(

new ErrorRecord(

new InvalidDataException(

string.Format(

CultureInfo.CurrentCulture,

Strings.WrongValueFormat,

element.Extent.StartLineNumber,

element.Extent.StartColumnNumber,

"")),

Strings.ConfigurationValueNotAString,

ErrorCategory.InvalidData,

null));

hasError = true;

continue;

}

rhsList.Add((element as StringConstantExpressionAst).Value);

}

}

}

}

if (rhsList.Count == 0)

{

writer.WriteError(

new ErrorRecord(

new InvalidDataException(

string.Format(

CultureInfo.CurrentCulture,

Strings.WrongValueFormat,

kvp.Item2.Extent.StartLineNumber,

kvp.Item2.Extent.StartColumnNumber,

profile)),

Strings.ConfigurationValueWrongFormat,

ErrorCategory.InvalidData,

profile));

hasError = true;

continue;

}

output[key] = rhsList;

}

return output;

}

/// <summary>

/// Recursively convert hashtable to dictionary

/// </summary>

/// <param name="hashtable"></param>

/// <returns>Dictionary that maps string to object</returns>

private Dictionary<string, object> GetDictionaryFromHashtable(

Hashtable hashtable,

IOutputWriter writer,

out bool hasError)

{

var dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

hasError = false;

foreach (var obj in hashtable.Keys)

{

string key = obj as string;

if (key == null)

{

writer.WriteError(

new ErrorRecord(

new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.KeyNotString, key)),

Strings.ConfigurationKeyNotAString,

ErrorCategory.InvalidData,

hashtable));

hasError = true;

return null;

}

var valueHashtableObj = hashtable[obj];

if (valueHashtableObj == null)

{

writer.WriteError(

new ErrorRecord(

new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, valueHashtableObj, key)),

Strings.WrongConfigurationKey,

ErrorCategory.InvalidData,

hashtable));

hasError = true;

return null;

}

var valueHashtable = valueHashtableObj as Hashtable;

if (valueHashtable == null)

{

dictionary.Add(key, valueHashtableObj);

}

else

{

var dict = GetDictionaryFromHashtable(valueHashtable, writer, out hasError);

if (dict != null)

{

dictionary.Add(key, dict);

}

else

{

return null;

}

}

}

return dictionary;

}

private bool ParseProfileHashtable(Hashtable profile, PathIntrinsics path, IOutputWriter writer,

List<string> severityList, List<string> includeRuleList, List<string> excludeRuleList)

{

bool hasError = false;

HashSet<string> validKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

validKeys.Add("severity");

validKeys.Add("includerules");

validKeys.Add("excluderules");

validKeys.Add("rules");

settings = GetDictionaryFromHashtable(profile, writer, out hasError);

if (hasError)

{

return hasError;

}

var settingsKeys = new string[settings.Keys.Count];

settings.Keys.CopyTo(settingsKeys, 0);

foreach (var settingKey in settingsKeys)

{

var key = settingKey.ToLower();

object value = settings[key];

switch (key)

{

case "severity":

case "includerules":

case "excluderules":

// value must be either string or collections of string or array

if (value == null

|| !(value is string

|| value is IEnumerable<string>

|| value.GetType().IsArray))

{

writer.WriteError(

new ErrorRecord(

new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, value, key)),

Strings.WrongConfigurationKey,

ErrorCategory.InvalidData,

profile));

hasError = true;

break;

}

List<string> values = new List<string>();

if (value is string)

{

values.Add(value as string);

}

else if (value is IEnumerable<string>)

{

values.Union(value as IEnumerable<string>);

}

else if (value.GetType().IsArray)

{

// for array case, sometimes we won't be able to cast it directly to IEnumerable<string>

foreach (var val in value as IEnumerable)

{

if (val is string)

{

values.Add(val as string);

}

else

{

writer.WriteError(

new ErrorRecord(

new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, val, key)),

Strings.WrongConfigurationKey,

ErrorCategory.InvalidData,

profile));

hasError = true;

break;

}

}

}

AddProfileItem(key, values, severityList, includeRuleList, excludeRuleList);

settings[key] = values;

break;

case "rules":

break;

default:

writer.WriteError(

new ErrorRecord(

new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongKeyHashTable, key)),

Strings.WrongConfigurationKey,

ErrorCategory.InvalidData,

profile));

hasError = true;

break;

}

}

return hasError;

}

private bool ParseProfileString(string profile, PathIntrinsics path, IOutputWriter writer,

List<string> severityList, List<string> includeRuleList, List<string> excludeRuleList)

{

bool hasError = false;

try

{

profile = path.GetResolvedPSPathFromPSPath(profile).First().Path;

}

catch

{

writer.WriteError(new ErrorRecord(new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, Strings.FileNotFound, profile)),

Strings.ConfigurationFileNotFound, ErrorCategory.ResourceUnavailable, profile));

hasError = true;

}

if (File.Exists(profile))

{

Token[] parserTokens = null;

ParseError[] parserErrors = null;

Ast profileAst = Parser.ParseFile(profile, out parserTokens, out parserErrors);

IEnumerable<Ast> hashTableAsts = profileAst.FindAll(item => item is HashtableAst, false);

// no hashtable, raise warning

if (hashTableAsts.Count() == 0)

{

writer.WriteError(new ErrorRecord(new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, profile)),

Strings.ConfigurationFileHasNoHashTable, ErrorCategory.ResourceUnavailable, profile));

hasError = true;

}

else

{

HashtableAst hashTableAst = hashTableAsts.First() as HashtableAst;

#if PSV3

settings = GetDictionaryFromHashTableAst(

hashTableAst,

writer,

profile,

out hasError);

foreach (var key in settings.Keys)

{

var rhsList = settings[key] as List<string>;

if (rhsList == null)

{

continue;

}

if (!AddProfileItem(key, rhsList, severityList, includeRuleList, excludeRuleList))

{

writer.WriteError(

new ErrorRecord(

new InvalidDataException(

string.Format(

CultureInfo.CurrentCulture,

Strings.WrongKey,

key,

profile)),

Strings.WrongConfigurationKey,

ErrorCategory.InvalidData,

profile));

hasError = true;

}

}

#else

try

{

var hashtable = hashTableAst.SafeGetValue() as Hashtable;

hasError = ParseProfileHashtable(hashtable, path, writer, severityList, includeRuleList, excludeRuleList);

}

catch

{

writer.WriteError(

new ErrorRecord(

new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, profile)),

Strings.ConfigurationFileHasInvalidHashtable,

ErrorCategory.ResourceUnavailable,

profile));

hasError = true;

}

#endif // PSV3

}

}

return hasError;

}

private void Initialize(

IOutputWriter outputWriter,

PathIntrinsics path,

CommandInvocationIntrinsics invokeCommand,

string[] customizedRulePath,

string[] includeRuleNames,

string[] excludeRuleNames,

string[] severity,

bool includeDefaultRules = false,

bool suppressedOnly = false,

string profile = null)

{

if (outputWriter == null)

{

throw new ArgumentNullException("outputWriter");

}

#if !PSV3

this.moduleHandler = null;

#endif

this.outputWriter = outputWriter;

#region Verifies rule extensions

List<string> paths = this.GetValidCustomRulePaths(customizedRulePath, path);

#endregion

#if CORECLR

// For Full CLR logger is loaded via Composition

// But for Core CLR we need to load it explicitly

this.Loggers = GetInterfaceImplementationsFromAssembly<ILogger>();

#endif

#region Initializes Rules

var includeRuleList = new List<string>();

var excludeRuleList = new List<string>();

var severityList = new List<string>();

if (profile != null)

{

ParseProfileString(profile, path, outputWriter, severityList, includeRuleList, excludeRuleList);

}

if (includeRuleNames != null)

{

foreach (string includeRuleName in includeRuleNames.Where(rule => !includeRuleList.Contains(rule, StringComparer.OrdinalIgnoreCase)))

{

includeRuleList.Add(includeRuleName);

}

}

if (excludeRuleNames != null)

{

foreach (string excludeRuleName in excludeRuleNames.Where(rule => !excludeRuleList.Contains(rule, StringComparer.OrdinalIgnoreCase)))

{

excludeRuleList.Add(excludeRuleName);

}

}

if (severity != null)

{

foreach (string sev in severity.Where(s => !severityList.Contains(s, StringComparer.OrdinalIgnoreCase)))

{

severityList.Add(sev);

}

}

this.suppressedOnly = suppressedOnly;

this.includeRegexList = new List<Regex>();

this.excludeRegexList = new List<Regex>();

if (this.severity == null)

{

this.severity = severityList.Count == 0 ? null : severityList.ToArray();

}

else

{

this.severity = this.severity.Union(severityList).ToArray();

}

if (this.includeRule == null)

{

this.includeRule = includeRuleList.Count == 0 ? null : includeRuleList.ToArray();

}

else

{

this.includeRule = this.includeRule.Union(includeRuleList).ToArray();

}

if (this.excludeRule == null)

{

this.excludeRule = excludeRuleList.Count == 0 ? null : excludeRuleList.ToArray();

}

else

{

this.excludeRule = this.excludeRule.Union(excludeRuleList).ToArray();

}

//Check wild card input for the Include/ExcludeRules and create regex match patterns

if (this.includeRule != null)

{

foreach (string rule in includeRule)

{

Regex includeRegex = new Regex(String.Format("^{0}$", Regex.Escape(rule).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);

this.includeRegexList.Add(includeRegex);

}

}

if (this.excludeRule != null)

{

foreach (string rule in excludeRule)

{

Regex excludeRegex = new Regex(String.Format("^{0}$", Regex.Escape(rule).Replace(@"\*", ".*")), RegexOptions.IgnoreCase);

this.excludeRegexList.Add(excludeRegex);

}

}

try

{

this.LoadRules(this.validationResults, invokeCommand, includeDefaultRules);

this.ConfigureScriptRules();

}

catch (Exception ex)

{

this.outputWriter.ThrowTerminatingError(

new ErrorRecord(

ex,

ex.HResult.ToString("X", CultureInfo.CurrentCulture),

ErrorCategory.NotSpecified, this));

}

#endregion

#region Verify rules

// Safely get one non-duplicated list of rules

IEnumerable<IRule> rules =

Enumerable.Union<IRule>(

Enumerable.Union<IRule>(

this.ScriptRules ?? Enumerable.Empty<IRule>(),

this.TokenRules ?? Enumerable.Empty<IRule>()),

this.ExternalRules ?? Enumerable.Empty<IExternalRule>());

// Ensure that rules were actually loaded

if (rules == null || rules.Any() == false)

{

this.outputWriter.ThrowTerminatingError(

new ErrorRecord(

new Exception(),

string.Format(

CultureInfo.CurrentCulture,

Strings.RulesNotFound),

ErrorCategory.ResourceExists,

this));

}

#endregion

}

private List<string> GetValidCustomRulePaths(string[] customizedRulePath, PathIntrinsics path)

{

List<string> paths = new List<string>();

if (customizedRulePath != null)

{

paths.AddRange(

customizedRulePath.ToList());

}

if (paths.Count > 0)

{

this.validationResults = this.CheckRuleExtension(paths.ToArray(), path);

foreach (string extension in this.validationResults["InvalidPaths"])

{

this.outputWriter.WriteWarning(string.Format(CultureInfo.CurrentCulture, Strings.MissingRuleExtension, extension));

}

}

else

{

this.validationResults = new Dictionary<string, List<string>>();

this.validationResults.Add("InvalidPaths", new List<string>());

this.validationResults.Add("ValidModPaths", new List<string>());

this.validationResults.Add("ValidDllPaths", new List<string>());

}

return paths;

}

private IEnumerable<T> GetInterfaceImplementationsFromAssembly<T>() where T : class

{

string dirName = Path.GetDirectoryName(typeof(ScriptAnalyzer).GetTypeInfo().Assembly.Location);

var dllPaths = Directory.EnumerateFiles(dirName, "*.dll", SearchOption.TopDirectoryOnly);

var objects = new List<T>();

foreach (var dllPath in dllPaths)

{

outputWriter.WriteVerbose(string.Format("Found Assembly: {0}", dllPath));

var objectsFromOneFile = GetInterfaceImplementationsFromAssembly<T>(dllPath);

objects.AddRange(objectsFromOneFile);

}

return objects;

}