{

#region Private members

private IOutputWriter outputWriter;

private CompositionContainer container;

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

// Initializes via ImportMany

[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; }

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");

}

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;

}

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

{

// profile was not given

if (profileObject == null)

{

return true;

}

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

{

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();

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 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");

foreach (var obj in profile.Keys)

{

string key = obj as string;

// key should be a string

if (key == null)

{

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

Strings.ConfigurationKeyNotAString, ErrorCategory.InvalidData, profile));

hasError = true;

continue;

}

// checks whether it falls into list of valid keys

if (!validKeys.Contains(key))

{

writer.WriteError(new ErrorRecord(

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

Strings.WrongConfigurationKey, ErrorCategory.InvalidData, profile));

hasError = true;

continue;

}

object value = profile[obj];

// 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;

continue;

}

// if we get here then everything is good

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;

continue;

}

}

}

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

}

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;

foreach (var kvp in hashTableAst.KeyValuePairs)

{

if (!(kvp.Item1 is StringConstantExpressionAst))

{

// 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;

}

// 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

{

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))

{

writer.WriteError(new ErrorRecord(new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongValueFormat, element.Extent.StartLineNumber, element.Extent.StartColumnNumber, profile)),

Strings.ConfigurationValueNotAString, ErrorCategory.InvalidData, profile));

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;

}

string key = (kvp.Item1 as StringConstantExpressionAst).Value.ToLower();

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

{

writer.WriteError(new ErrorRecord(

new InvalidDataException(string.Format(CultureInfo.CurrentCulture, Strings.WrongKey, key, kvp.Item1.Extent.StartLineNumber, kvp.Item1.Extent.StartColumnNumber, profile)),

Strings.WrongConfigurationKey, ErrorCategory.InvalidData, profile));

hasError = true;

}

}

}

}

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 and loggers path

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

#endregion

#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);

}

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 void LoadRules(Dictionary<string, List<string>> result, CommandInvocationIntrinsics invokeCommand, bool loadBuiltInRules)

{

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

// Initialize helper

Helper.Instance = new Helper(invokeCommand, this.outputWriter);

Helper.Instance.Initialize();

// Clear external rules for each invoke.

this.ScriptRules = null;

this.TokenRules = null;

this.ExternalRules = null;

// An aggregate catalog that combines multiple catalogs.

using (AggregateCatalog catalog = new AggregateCatalog())

{

// Adds all the parts found in the same directory.

string dirName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

catalog.Catalogs.Add(

new SafeDirectoryCatalog(

dirName,

this.outputWriter));

// Adds user specified directory

paths = result.ContainsKey("ValidDllPaths") ? result["ValidDllPaths"] : result["ValidPaths"];

foreach (string path in paths)

{

if (String.Equals(Path.GetExtension(path), ".dll", StringComparison.OrdinalIgnoreCase))

{

catalog.Catalogs.Add(new AssemblyCatalog(path));

}

else

{

catalog.Catalogs.Add(

new SafeDirectoryCatalog(

path,

this.outputWriter));

}

}

// Creates the CompositionContainer with the parts in the catalog.

container = new CompositionContainer(catalog);

// Fills the imports of this object.

try

{

container.ComposeParts(this);

}

catch (CompositionException compositionException)

{

this.outputWriter.WriteWarning(compositionException.ToString());

}

}

if (!loadBuiltInRules)

{

this.ScriptRules = null;

}

// Gets external rules.

if (result.ContainsKey("ValidModPaths") && result["ValidModPaths"].Count > 0)

{

ExternalRules = GetExternalRule(result["ValidModPaths"].ToArray());

}

}

internal string[] GetValidModulePaths()

{

List<string> validModulePaths = null;

if (!this.validationResults.TryGetValue("ValidModPaths", out validModulePaths))

{

validModulePaths = new List<string>();

}

return validModulePaths.ToArray();

}

public IEnumerable<IRule> GetRule(string[] moduleNames, string[] ruleNames)

{

IEnumerable<IRule> results = null;

IEnumerable<IExternalRule> externalRules = null;

// Combines C# rules.

IEnumerable<IRule> rules = Enumerable.Empty<IRule>();

if (null != ScriptRules)

{

rules = ScriptRules.Union<IRule>(TokenRules).Union<IRule>(DSCResourceRules);

}

// Gets PowerShell Rules.

if (moduleNames != null)

{

externalRules = GetExternalRule(moduleNames);

rules = rules.Union<IRule>(externalRules);

}

if (ruleNames != null)

{

//Check wild card input for -Name parameter and create regex match patterns

List<Regex> regexList = new List<Regex>();

foreach (string ruleName in ruleNames)

{

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

regexList.Add(includeRegex);

}

results = from rule in rules

from regex in regexList

where regex.IsMatch(rule.GetName())

select rule;

}

else

{

results = rules;

}

return results;

}

private List<ExternalRule> GetExternalRule(string[] moduleNames)

{

List<ExternalRule> rules = new List<ExternalRule>();

if (moduleNames == null) return rules;

// Converts module path to module name.

foreach (string moduleName in moduleNames)

{

string shortModuleName = string.Empty;

// Imports modules by using full path.

InitialSessionState state = InitialSessionState.CreateDefault2();

using (System.Management.Automation.PowerShell posh =

System.Management.Automation.PowerShell.Create(state))

{

posh.AddCommand("Import-Module").AddArgument(moduleName).AddParameter("PassThru");

Collection<PSModuleInfo> loadedModules = posh.Invoke<PSModuleInfo>();

if (loadedModules != null && loadedModules.Count > 0)

{

shortModuleName = loadedModules.First().Name;

}

// Invokes Get-Command and Get-Help for each functions in the module.

posh.Commands.Clear();

posh.AddCommand("Get-Command").AddParameter("Module", shortModuleName);

var psobjects = posh.Invoke();

foreach (PSObject psobject in psobjects)

{

posh.Commands.Clear();

FunctionInfo funcInfo = (FunctionInfo)psobject.ImmediateBaseObject;

ParameterMetadata param = null;

// Ignore any exceptions associated with finding functions that are ScriptAnalyzer rules

try

{

param = funcInfo.Parameters.Values.First<ParameterMetadata>(item => item.Name.EndsWith("ast", StringComparison.OrdinalIgnoreCase) ||

item.Name.EndsWith("token", StringComparison.OrdinalIgnoreCase));

}

catch

{

}

//Only add functions that are defined as rules.

if (param != null)

{

// On a new image, when Get-Help is run the first time, PowerShell offers to download updated help content

// using Update-Help. This results in an interactive prompt - which we cannot handle

// Workaround to prevent Update-Help from running is to set the following reg key

// HKLM:\Software\Microsoft\PowerShell\DisablePromptToUpdateHelp

// OR execute Update-Help in an elevated admin mode before running ScriptAnalyzer

Collection<PSObject> helpContent = null;

try

{

posh.AddCommand("Get-Help").AddParameter("Name", funcInfo.Name);

helpContent = posh.Invoke();

}

catch (Exception getHelpException)

{

this.outputWriter.WriteWarning(getHelpException.Message.ToString());

}

// Retrieve "Description" field in the help content

string desc = String.Empty;

if ((null != helpContent) && ( 1 == helpContent.Count))

{

dynamic description = helpContent[0].Properties["Description"];

if (null != description && null != description.Value && description.Value.GetType().IsArray)

{

desc = description.Value[0].Text;

}