From 9914b5b8cba6d98c2f6e230cfaa589378037fd2e Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Mon, 3 Feb 2020 17:53:19 -0600
Subject: [PATCH 01/18] Update Get-LogWinEvent.ps1

---
 Modules/Log/Get-LogWinEvent.ps1 | 170 +++++++++++++++++++++++++++++---
 1 file changed, 156 insertions(+), 14 deletions(-)

diff --git a/Modules/Log/Get-LogWinEvent.ps1 b/Modules/Log/Get-LogWinEvent.ps1
index ceeb1844..2f433615 100644
--- a/Modules/Log/Get-LogWinEvent.ps1
+++ b/Modules/Log/Get-LogWinEvent.ps1
@@ -1,30 +1,172 @@
-<# 
+<# 
 .SYNOPSIS
-Get-LogWinEvent
+    Get-LogWinEvent
+
 .PARAMETER LogName
-A required parameter, that names the event log to acquire data from.
-To see a list of common lognames run:
-Get-WinEvent -ListLog | Select LogName
+    A required parameter, that names the event log to acquire data from.
+    To see a list of common lognames run: Get-WinEvent -ListLog | Select LogName
+    
+    Note: it is now possible to specify multiple LogNames - see the example below.
+    Note: when used with Kansa.ps1, parameters must be positional. Named params are not supported.
+
+.PARAMETER DaysAgo
+    An optional parameter that allows you to specify how many days back you'd like logs for
+
+.PARAMETER EventIDs
+    An optional parameter that allows you to filter on event IDs... just in case you want a select few, rather than all.
+    Note: it is possible to specify multiple event IDs - see the example below.
 
-When used with Kansa.ps1, parameters must be positional. Named params
-are not supported.
 .EXAMPLE
-Get-LogWinEvent.ps1 Security
+    Get-LogWinEvent.ps1 Security
+
+.EXAMPLE
+    Get-LogWinEvent.ps1 Security,System 7 4625,4634,4798,267,507
+
+.EX
+
 .NOTES
-When passing specific modules with parameters via Kansa.ps1's
--ModulePath parameter, be sure to quote the entire string, like shown
-here:
-.\kansa.ps1 -Target localhost -ModulePath ".\Modules\Log\Get-LogWinEvent.ps1 Security"
+    When passing specific modules with parameters via Kansa.ps1's -ModulePath parameter, be sure to quote the entire string, like shown
+    here:
+    .\kansa.ps1 -Target localhost -ModulePath ".\Modules\Log\Get-LogWinEvent.ps1 Security"
+    
+    Thanks to Jeff Hicks for providng the Convert-EventLogRecord function, which allows for enhanced event log collections!
+    Original blog post found here: https://jdhitsolutions.com/blog/powershell/7193/better-event-logs-with-powershell/
 
 Next line is required by Kansa for proper handling of this script's
 output.
+
 OUTPUT TSV
 #>
 
 [CmdletBinding()]
 Param(
     [Parameter(Mandatory=$True,Position=0)]
-        [String]$LogName
+    [String[]]$LogName,
+    [Parameter(Mandatory=$False,Position=1)]
+    $DaysAgo = $null,
+    [Parameter(Mandatory=$False,Position=2)]
+    [String[]]$EventIDs = $null
 )
 
-Get-WinEvent -LogName $LogName
\ No newline at end of file
+Function Convert-EventLogRecord {
+
+    [cmdletbinding()]
+    [alias("clr")]
+
+    Param(
+        [Parameter(Position = 0, Mandatory, ValueFromPipeline)]
+        [ValidateNotNullorEmpty()]
+        [System.Diagnostics.Eventing.Reader.EventLogRecord[]]$LogRecord
+    )
+
+    Begin {
+        Write-Verbose "[BEGIN  ] Starting: $($MyInvocation.Mycommand)"
+    } #begin
+
+    Process {
+        foreach ($record in $LogRecord) {
+            Write-Verbose "[PROCESS] Processing event id $($record.ID) from $($record.logname) log on $($record.machinename)"
+            Write-Verbose "[PROCESS] Creating XML data"
+            [xml]$r = $record.ToXml()
+
+            $h = [ordered]@{
+                LogName     = $record.LogName
+                RecordType  = $record.LevelDisplayName
+                TimeCreated = $record.TimeCreated
+                ID          = $record.Id
+            }
+
+            if ($r.Event.EventData.Data.Count -gt 0) {
+                Write-Verbose "[PROCESS] Parsing event data"
+                if ($r.Event.EventData.Data -is [array]) {
+                <#
+                 I only want to enumerate with the For loop if the data is an array of objects
+                 If the data is just a single string like Foo, then when using the For loop,
+                 the data value will be the F and not the complete string, Foo.
+                 #>
+                for ($i = 0; $i -lt $r.Event.EventData.Data.count; $i++) {
+
+                    $data = $r.Event.EventData.data[$i]
+                    #test if there is structured data or just text
+                    if ($data.name) {
+                        $Name = $data.name
+                        $Value = $data.'#text'
+                    }
+                    else {
+                        Write-Verbose "[PROCESS] No data property name detected"
+                        $Name = "RawProperties"
+                        #data will likely be an array of strings
+                        [string[]]$Value = $data
+                    }
+
+                    if ($h.Contains("RawProperties")) {
+                        Write-Verbose "[PROCESS] Appending to RawProperties"
+                        $h.RawProperties += $value
+                    }
+                    else {
+                        Write-Verbose "[PROCESS] Adding $name"
+                        $h.add($name, $Value)
+                    }
+                } #for data
+                } #data is an array
+                else {
+                    $data = $r.Event.EventData.data
+                    if ($data.name) {
+                        $Name = $data.name
+                        $Value = $data.'#text'
+                    }
+                    else {
+                        Write-Verbose "[PROCESS] No data property name detected"
+                        $Name = "RawProperties"
+                        #data will likely be an array of strings
+                        [string[]]$Value = $data
+                    }
+
+                    if ($h.Contains("RawProperties")) {
+                        Write-Verbose "[PROCESS] Appending to RawProperties"
+                        $h.RawProperties += $value
+                    }
+                    else {
+                        Write-Verbose "[PROCESS] Adding $name"
+                        $h.add($name, $Value)
+                    }
+                }
+            } #if data
+            else {
+                Write-Verbose "[PROCESS] No event data to process"
+            }
+
+            $h.Add("Message", $record.Message)
+            $h.Add("Keywords", $record.KeywordsDisplayNames)
+            $h.Add("Source", $record.ProviderName)
+            $h.Add("Computername", $record.MachineName)
+
+            Write-Verbose "[PROCESS] Creating custom object"
+            New-Object -TypeName PSObject -Property $h
+        } #foreach record
+    } #process
+
+    End {
+        Write-Verbose "[END    ] Ending: $($MyInvocation.Mycommand)"
+    } #end
+} #end Convert-EventLogRecord
+
+If ($DaysAgo -eq $null) {
+    $StartDate = $($(Get-WinEvent -LogName Security -Oldest -MaxEvents 1).TimeCreated)
+    $EndDate = Get-Date
+    $Span = $(New-TimeSpan -Start $StartDate -End $EndDate).Days
+} # end If
+Else {$Span = $DaysAgo} # end else
+
+$StartTime = (Get-Date).AddDays(-$Span)
+
+if ($EventIDs.Count -eq 0) {
+    Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime} -EA SilentlyContinue  | Convert-EventLogRecord
+} # end If
+else {
+    ForEach ($log in $LogName) {
+        ForEach ($id in $EventIDs) {
+            Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime; ID=$id} -EA SilentlyContinue  | Convert-EventLogRecord
+        } # end inner ForEach ($id in $EventIDs)
+    } # end outter ForEach ($log in LogName)
+} # end else

From 48762bf723849bd383d68828f2ca5fc00bbce536 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Mon, 3 Feb 2020 17:54:30 -0600
Subject: [PATCH 02/18] Update Get-LogWinEvent.ps1

---
 Modules/Log/Get-LogWinEvent.ps1 | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Modules/Log/Get-LogWinEvent.ps1 b/Modules/Log/Get-LogWinEvent.ps1
index 2f433615..bdf39d93 100644
--- a/Modules/Log/Get-LogWinEvent.ps1
+++ b/Modules/Log/Get-LogWinEvent.ps1
@@ -10,7 +10,9 @@
     Note: when used with Kansa.ps1, parameters must be positional. Named params are not supported.
 
 .PARAMETER DaysAgo
-    An optional parameter that allows you to specify how many days back you'd like logs for
+    An optional parameter that allows you to specify how many days back you'd like to gather logs.
+    
+    Note: If this parameter is left blank, you'll gather "all the logs".
 
 .PARAMETER EventIDs
     An optional parameter that allows you to filter on event IDs... just in case you want a select few, rather than all.

From 53248a4cb7d19c85aac2d922f22f7b1db4a5e126 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Mon, 3 Feb 2020 22:41:22 -0600
Subject: [PATCH 03/18] Update Get-LogWinEvent.ps1

Got a little ahead of myself.
---
 Modules/Log/Get-LogWinEvent.ps1 | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Modules/Log/Get-LogWinEvent.ps1 b/Modules/Log/Get-LogWinEvent.ps1
index bdf39d93..5df0b969 100644
--- a/Modules/Log/Get-LogWinEvent.ps1
+++ b/Modules/Log/Get-LogWinEvent.ps1
@@ -163,7 +163,9 @@ Else {$Span = $DaysAgo} # end else
 $StartTime = (Get-Date).AddDays(-$Span)
 
 if ($EventIDs.Count -eq 0) {
-    Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime} -EA SilentlyContinue  | Convert-EventLogRecord
+    ForEach ($log in $LogName) {
+        Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime} -EA SilentlyContinue  | Convert-EventLogRecord
+    } # end outter ForEach ($log in LogName)
 } # end If
 else {
     ForEach ($log in $LogName) {

From 79a700e55afa35628ce37d6832da2f3bee13fd73 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Tue, 14 Apr 2020 22:04:10 -0500
Subject: [PATCH 04/18] Update Get-LogWinEvent.ps1

---
 Modules/Log/Get-LogWinEvent.ps1 | 302 +++++++++++++++++---------------
 1 file changed, 158 insertions(+), 144 deletions(-)

diff --git a/Modules/Log/Get-LogWinEvent.ps1 b/Modules/Log/Get-LogWinEvent.ps1
index 5df0b969..83b1020b 100644
--- a/Modules/Log/Get-LogWinEvent.ps1
+++ b/Modules/Log/Get-LogWinEvent.ps1
@@ -1,31 +1,23 @@
 <# 
 .SYNOPSIS
     Get-LogWinEvent
+.PARAMETER Params
+    A required parameter. I'll call this a pseudo parameter. This is due to the fact that you, the user, is really providing 3 parameters
+    worth of information that later gets parsed out in to separate parameters.
 
-.PARAMETER LogName
-    A required parameter, that names the event log to acquire data from.
-    To see a list of common lognames run: Get-WinEvent -ListLog | Select LogName
-    
-    Note: it is now possible to specify multiple LogNames - see the example below.
+    The format for this parameter follows this syntax: log name(s) [separated by a pipe if you want to specify more than one]-days ago-event IDs [separated
+    by a pipe if you want to specify more than one].
+        
     Note: when used with Kansa.ps1, parameters must be positional. Named params are not supported.
 
-.PARAMETER DaysAgo
-    An optional parameter that allows you to specify how many days back you'd like to gather logs.
-    
-    Note: If this parameter is left blank, you'll gather "all the logs".
-
-.PARAMETER EventIDs
-    An optional parameter that allows you to filter on event IDs... just in case you want a select few, rather than all.
-    Note: it is possible to specify multiple event IDs - see the example below.
-
 .EXAMPLE
+    Single log, no additional filtering:
     Get-LogWinEvent.ps1 Security
 
 .EXAMPLE
-    Get-LogWinEvent.ps1 Security,System 7 4625,4634,4798,267,507
-
+    Multiple logs, over the past 7 days, with specified Event IDs
+    Get-LogWinEvent.ps1 Security|System-7-4625|4634|4798|267|507
 .EX
-
 .NOTES
     When passing specific modules with parameters via Kansa.ps1's -ModulePath parameter, be sure to quote the entire string, like shown
     here:
@@ -36,141 +28,163 @@
 
 Next line is required by Kansa for proper handling of this script's
 output.
-
 OUTPUT TSV
 #>
 
-[CmdletBinding()]
-Param(
-    [Parameter(Mandatory=$True,Position=0)]
-    [String[]]$LogName,
-    [Parameter(Mandatory=$False,Position=1)]
-    $DaysAgo = $null,
-    [Parameter(Mandatory=$False,Position=2)]
-    [String[]]$EventIDs = $null
-)
-
-Function Convert-EventLogRecord {
-
-    [cmdletbinding()]
-    [alias("clr")]
-
+    [CmdletBinding()]
     Param(
-        [Parameter(Position = 0, Mandatory, ValueFromPipeline)]
-        [ValidateNotNullorEmpty()]
-        [System.Diagnostics.Eventing.Reader.EventLogRecord[]]$LogRecord
+        [Parameter(Mandatory=$True,Position=0)]
+        [String]$Params
     )
 
-    Begin {
-        Write-Verbose "[BEGIN  ] Starting: $($MyInvocation.Mycommand)"
-    } #begin
-
-    Process {
-        foreach ($record in $LogRecord) {
-            Write-Verbose "[PROCESS] Processing event id $($record.ID) from $($record.logname) log on $($record.machinename)"
-            Write-Verbose "[PROCESS] Creating XML data"
-            [xml]$r = $record.ToXml()
-
-            $h = [ordered]@{
-                LogName     = $record.LogName
-                RecordType  = $record.LevelDisplayName
-                TimeCreated = $record.TimeCreated
-                ID          = $record.Id
-            }
-
-            if ($r.Event.EventData.Data.Count -gt 0) {
-                Write-Verbose "[PROCESS] Parsing event data"
-                if ($r.Event.EventData.Data -is [array]) {
-                <#
-                 I only want to enumerate with the For loop if the data is an array of objects
-                 If the data is just a single string like Foo, then when using the For loop,
-                 the data value will be the F and not the complete string, Foo.
-                 #>
-                for ($i = 0; $i -lt $r.Event.EventData.Data.count; $i++) {
-
-                    $data = $r.Event.EventData.data[$i]
-                    #test if there is structured data or just text
-                    if ($data.name) {
-                        $Name = $data.name
-                        $Value = $data.'#text'
-                    }
-                    else {
-                        Write-Verbose "[PROCESS] No data property name detected"
-                        $Name = "RawProperties"
-                        #data will likely be an array of strings
-                        [string[]]$Value = $data
-                    }
+    $unparsedLogSelection = ($params -split "-")[0]
+    $daysAgo = ($params -split "-")[1]
+    $unparsedEventIDs = ($params -split "-")[2]
+
+    # At a minimum, the user needs to specify at least one log name. If a valid log name is not specified,
+    # The script fails.
+    [String[]]$LogName = $unparsedLogSelection -split "\|"
+
+    # Add a check to see if $daysAgo is populated - technically, it is an optional parameter.
+    # If the user declined to specify, set $daysAgo to $null and search through all the logs.
+    if ($daysAgo -eq $null) {
+        $daysAgo = $null
+    }
+    else {
+        [int]$daysAgo = $daysAgo
+    }
+
+    # Add a check to see if we need to populate $EventIDs. It too is an optional patameter.
+    # If the user declined to specify a list of event ids, set the parameter to $null and get all of the
+    # event ids for the specified log(s).
+    if ($unparsedEventIDs -eq $null) {
+        $EventIDs = $null
+    }
+    else {
+        [String[]]$EventIDs = $unparsedEventIDs -split "\|"
+    }
+
+    Function Convert-EventLogRecord {
+
+        [cmdletbinding()]
+        [alias("clr")]
+
+        Param(
+            [Parameter(Position = 0, Mandatory, ValueFromPipeline)]
+            [ValidateNotNullorEmpty()]
+            [System.Diagnostics.Eventing.Reader.EventLogRecord[]]$LogRecord
+        )
+
+        Begin {
+            Write-Verbose "[BEGIN  ] Starting: $($MyInvocation.Mycommand)"
+        } #begin
+
+        Process {
+            foreach ($record in $LogRecord) {
+                Write-Verbose "[PROCESS] Processing event id $($record.ID) from $($record.logname) log on $($record.machinename)"
+                Write-Verbose "[PROCESS] Creating XML data"
+                [xml]$r = $record.ToXml()
+
+                $h = [ordered]@{
+                    LogName     = $record.LogName
+                    RecordType  = $record.LevelDisplayName
+                    TimeCreated = $record.TimeCreated
+                    ID          = $record.Id
+                }
 
-                    if ($h.Contains("RawProperties")) {
-                        Write-Verbose "[PROCESS] Appending to RawProperties"
-                        $h.RawProperties += $value
-                    }
+                if ($r.Event.EventData.Data.Count -gt 0) {
+                    Write-Verbose "[PROCESS] Parsing event data"
+                    if ($r.Event.EventData.Data -is [array]) {
+                    <#
+                     I only want to enumerate with the For loop if the data is an array of objects
+                     If the data is just a single string like Foo, then when using the For loop,
+                     the data value will be the F and not the complete string, Foo.
+                     #>
+                    for ($i = 0; $i -lt $r.Event.EventData.Data.count; $i++) {
+
+                        $data = $r.Event.EventData.data[$i]
+                        #test if there is structured data or just text
+                        if ($data.name) {
+                            $Name = $data.name
+                            $Value = $data.'#text'
+                        }
+                        else {
+                            Write-Verbose "[PROCESS] No data property name detected"
+                            $Name = "RawProperties"
+                            #data will likely be an array of strings
+                            [string[]]$Value = $data
+                        }
+
+                        if ($h.Contains("RawProperties")) {
+                            Write-Verbose "[PROCESS] Appending to RawProperties"
+                            $h.RawProperties += $value
+                        }
+                        else {
+                            Write-Verbose "[PROCESS] Adding $name"
+                            $h.add($name, $Value)
+                        }
+                    } #for data
+                    } #data is an array
                     else {
-                        Write-Verbose "[PROCESS] Adding $name"
-                        $h.add($name, $Value)
+                        $data = $r.Event.EventData.data
+                        if ($data.name) {
+                            $Name = $data.name
+                            $Value = $data.'#text'
+                        }
+                        else {
+                            Write-Verbose "[PROCESS] No data property name detected"
+                            $Name = "RawProperties"
+                            #data will likely be an array of strings
+                            [string[]]$Value = $data
+                        }
+
+                        if ($h.Contains("RawProperties")) {
+                            Write-Verbose "[PROCESS] Appending to RawProperties"
+                            $h.RawProperties += $value
+                        }
+                        else {
+                            Write-Verbose "[PROCESS] Adding $name"
+                            $h.add($name, $Value)
+                        }
                     }
-                } #for data
-                } #data is an array
+                } #if data
                 else {
-                    $data = $r.Event.EventData.data
-                    if ($data.name) {
-                        $Name = $data.name
-                        $Value = $data.'#text'
-                    }
-                    else {
-                        Write-Verbose "[PROCESS] No data property name detected"
-                        $Name = "RawProperties"
-                        #data will likely be an array of strings
-                        [string[]]$Value = $data
-                    }
-
-                    if ($h.Contains("RawProperties")) {
-                        Write-Verbose "[PROCESS] Appending to RawProperties"
-                        $h.RawProperties += $value
-                    }
-                    else {
-                        Write-Verbose "[PROCESS] Adding $name"
-                        $h.add($name, $Value)
-                    }
+                    Write-Verbose "[PROCESS] No event data to process"
                 }
-            } #if data
-            else {
-                Write-Verbose "[PROCESS] No event data to process"
-            }
-
-            $h.Add("Message", $record.Message)
-            $h.Add("Keywords", $record.KeywordsDisplayNames)
-            $h.Add("Source", $record.ProviderName)
-            $h.Add("Computername", $record.MachineName)
-
-            Write-Verbose "[PROCESS] Creating custom object"
-            New-Object -TypeName PSObject -Property $h
-        } #foreach record
-    } #process
-
-    End {
-        Write-Verbose "[END    ] Ending: $($MyInvocation.Mycommand)"
-    } #end
-} #end Convert-EventLogRecord
-
-If ($DaysAgo -eq $null) {
-    $StartDate = $($(Get-WinEvent -LogName Security -Oldest -MaxEvents 1).TimeCreated)
-    $EndDate = Get-Date
-    $Span = $(New-TimeSpan -Start $StartDate -End $EndDate).Days
-} # end If
-Else {$Span = $DaysAgo} # end else
-
-$StartTime = (Get-Date).AddDays(-$Span)
-
-if ($EventIDs.Count -eq 0) {
-    ForEach ($log in $LogName) {
-        Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime} -EA SilentlyContinue  | Convert-EventLogRecord
-    } # end outter ForEach ($log in LogName)
-} # end If
-else {
-    ForEach ($log in $LogName) {
-        ForEach ($id in $EventIDs) {
-            Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime; ID=$id} -EA SilentlyContinue  | Convert-EventLogRecord
-        } # end inner ForEach ($id in $EventIDs)
-    } # end outter ForEach ($log in LogName)
-} # end else
+
+                $h.Add("Message", $record.Message)
+                $h.Add("Keywords", $record.KeywordsDisplayNames)
+                $h.Add("Source", $record.ProviderName)
+                $h.Add("Computername", $record.MachineName)
+
+                Write-Verbose "[PROCESS] Creating custom object"
+                New-Object -TypeName PSObject -Property $h
+            } #foreach record
+        } #process
+
+        End {
+            Write-Verbose "[END    ] Ending: $($MyInvocation.Mycommand)"
+        } #end
+    } #end Convert-EventLogRecord
+
+    If ($DaysAgo -eq $null) {
+        $StartDate = $($(Get-WinEvent -LogName Security -Oldest -MaxEvents 1).TimeCreated)
+        $EndDate = Get-Date
+        $Span = $(New-TimeSpan -Start $StartDate -End $EndDate).Days
+    } # end If
+    Else {$Span = $DaysAgo} # end else
+
+    $StartTime = (Get-Date).AddDays(-$Span)
+
+    if ($EventIDs.Count -eq 0) {
+        ForEach ($log in $LogName) {
+            Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime} -EA SilentlyContinue  | Convert-EventLogRecord
+        } # end ForEach ($log in LogName)
+    } # end If
+    else {
+        ForEach ($log in $LogName) {
+            ForEach ($id in $EventIDs) {
+                Get-WinEvent -FilterHashtable @{ Logname=$LogName; StartTime=$StartTime; ID=$id} -EA SilentlyContinue  | Convert-EventLogRecord
+            } # end inner ForEach ($id in $EventIDs)
+        } # end outter ForEach ($log in LogName)
+    } # end else

From f70d235b1df444fd2d773dab71b29a1ae2e87354 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Tue, 14 Apr 2020 22:28:11 -0500
Subject: [PATCH 05/18] Update README.md

---
 README.md | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 06e93ee2..2ada75f2 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ But really, upgrade to PSv3 or later. Be happy.
 
 More info:  
 http://trustedsignal.blogspot.com/search/label/Kansa  
-http://www.powershellmagazine.com/2014/07/18/kansa-a-powershell-based-incident-response-framework/  
+http://www.powershellmagazine.com/2014/07/18/kansa-a-powershell-based-incident-response-framework/
 
 ## What does it do?
 It uses Powershell Remoting to run user contributed, ahem, user contri-  
@@ -78,6 +78,29 @@ cmdlets. Here's an example:
 the result of the above will be a file called netstat.tsv containing  
 unquoted, tab separate values for netstat -naob's ouput.
 
+## Expanded use cases
+Over the past few years, additional output types have been added to Kansa, and several modules have been added or expanded.
+
+### Sending output to a log aggregator
+It is now possible to configure Kansa to send collected data to Splunk or GrayLog for analysis and retention. In order to do so, configure the proper parameters in ```logging.conf```.
+```Powershell
+.\kansa.ps1 -Target $env:COMPUTERNAME -Authentication Default -OutputFormat SPLUNK
+```
+A quick tutorial on setting up Splunk to receive data from Kansa is available here: https://powerhunt.org/enterprise-dfir-on-a-budget/
+
+### Enhanced Windows Event Log retrieval
+```.\Modules\Log\Get-LogWinEvent``` has been modified to allow the user to specify multiple parameters to allow for greater filtering, as well as enhanced parsing of the message body, which is handy if the destination is a log aggregator.
+
+Due to the way in which Kansa parses module names and accompanying parameters, the parameter passed to ```Get-LogWinEvent``` is encodes 3 data points in to one pseudo parameter - the log name(s), how many days back the user wishes to search, and the event IDs the user wishes to filter on. **Only the log name(s) are mandatory***
+
+In Modules.conf, you can specify the parameter(s) for Get-LogWinEvent as such:
+```Log\Get-LogWinEvent2.ps1 Security|Application|System-7-4624|1003|1014```
+
+Or, if you wish to call ```Get-LogWinEvent``` as a stand alone module:
+```
+.\kansa.ps1 -Target $env:COMPUTERNAME -Authentication Default -ModulePath ".\Modules\Log\Get-LogWinEvent2.ps1 Security-7-4624"
+```
+
 ## Caveats:
 Powershell relies on the Windows API. Your adversary may use subterfuge.*
 

From 998ab5c5b21170f8e754abfffa0b2bdbf21ab5ff Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Tue, 14 Apr 2020 22:29:21 -0500
Subject: [PATCH 06/18] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 2ada75f2..9162e08c 100644
--- a/README.md
+++ b/README.md
@@ -97,7 +97,7 @@ In Modules.conf, you can specify the parameter(s) for Get-LogWinEvent as such:
 ```Log\Get-LogWinEvent2.ps1 Security|Application|System-7-4624|1003|1014```
 
 Or, if you wish to call ```Get-LogWinEvent``` as a stand alone module:
-```
+```Powershell
 .\kansa.ps1 -Target $env:COMPUTERNAME -Authentication Default -ModulePath ".\Modules\Log\Get-LogWinEvent2.ps1 Security-7-4624"
 ```
 

From b499bbb905767ead7667182746952c75fe86f3ac Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Tue, 14 Apr 2020 22:30:01 -0500
Subject: [PATCH 07/18] Update README.md

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 9162e08c..28de764d 100644
--- a/README.md
+++ b/README.md
@@ -94,11 +94,11 @@ A quick tutorial on setting up Splunk to receive data from Kansa is available he
 Due to the way in which Kansa parses module names and accompanying parameters, the parameter passed to ```Get-LogWinEvent``` is encodes 3 data points in to one pseudo parameter - the log name(s), how many days back the user wishes to search, and the event IDs the user wishes to filter on. **Only the log name(s) are mandatory***
 
 In Modules.conf, you can specify the parameter(s) for Get-LogWinEvent as such:
-```Log\Get-LogWinEvent2.ps1 Security|Application|System-7-4624|1003|1014```
+```Log\Get-LogWinEvent.ps1 Security|Application|System-7-4624|1003|1014```
 
 Or, if you wish to call ```Get-LogWinEvent``` as a stand alone module:
 ```Powershell
-.\kansa.ps1 -Target $env:COMPUTERNAME -Authentication Default -ModulePath ".\Modules\Log\Get-LogWinEvent2.ps1 Security-7-4624"
+.\kansa.ps1 -Target $env:COMPUTERNAME -Authentication Default -ModulePath ".\Modules\Log\Get-LogWinEvent.ps1 Security-7-4624"
 ```
 
 ## Caveats:

From ed257f1638e1b70c4bec5803e869a0e27019fe92 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Tue, 14 Apr 2020 22:33:44 -0500
Subject: [PATCH 08/18] Update README.md

---
 README.md | 54 +++++++++++++-----------------------------------------
 1 file changed, 13 insertions(+), 41 deletions(-)

diff --git a/README.md b/README.md
index 28de764d..f3c46b4f 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,7 @@
 Kansa
 =====
 
-A modular incident response framework in Powershell. It's been tested in PSv2 / .NET 2 and
-later and works mostly without issue.
+A modular incident response framework in Powershell. It's been tested in PSv2 / .NET 2 and later and works mostly without issue.
 
 But really, upgrade to PSv3 or later. Be happy.
 
@@ -11,19 +10,12 @@ http://trustedsignal.blogspot.com/search/label/Kansa
 http://www.powershellmagazine.com/2014/07/18/kansa-a-powershell-based-incident-response-framework/
 
 ## What does it do?
-It uses Powershell Remoting to run user contributed, ahem, user contri-  
-buted modules across hosts in an enterprise to collect data for use  
-during incident response, breach hunts, or for building an environmental  
-baseline.
+It uses Powershell Remoting to run user contributed, ahem, user contributed modules across hosts in an enterprise to collect data for use during incident response, breach hunts, or for building an environmental  baseline.
 
 ## How do you use it?
-Here's a very simple command line example you can run on your own local  
-host.  
+Here's a very simple command line example you can run on your own local host.  
 
-1.  After downloading the project and unzipping it, you'll likely need  
-to "unblock" the ps1 files. The easiest way to do this if you're using  
-Powershell v3 or later is to cd to the directory where Kansa resides  
-and do:  
+1.  After downloading the project and unzipping it, you'll likely need to "unblock" the ps1 files. The easiest way to do this if you're using Powershell v3 or later is to cd to the directory where Kansa resides and do:  
 ```Powershell
 ls -r *.ps1 | Unblock-File
 ```
@@ -31,52 +23,32 @@ ls -r *.ps1 | Unblock-File
 ```
 Set-ExecutionPolicy AllSigned | RemoteSigned | Unrestricted
 ```
-1. If you're not running PS v3 or later, [Sysinternal's Streams utility](https://technet.microsoft.com/en-us/sysinternals/streams.aspx) can  
-be used to remove the alternate data streams that Powershell uses to  
-determine if files came from the Internet. Once you've removed those  
-ADSes, you'll be able to run the scripts without issue.  
+1. If you're not running PS v3 or later, [Sysinternal's Streams utility](https://technet.microsoft.com/en-us/sysinternals/streams.aspx) can be used to remove the alternate data streams that Powershell uses to determine if files came from the Internet. Once you've removed those ADSes, you'll be able to run the scripts without issue.  
 ```
 c:\ streams -sd <Kansa directory>
 ```
 
-I've not run into any issues running the downloaded scripts via Windows  
-Remote Management / Powershell Remoting through Kansa, so you shouldn't  
-have to do anything if you want to run the scripts via remoting.  
+I've not run into any issues running the downloaded scripts via Windows Remote Management / Powershell Remoting through Kansa, so you shouldn't have to do anything if you want to run the scripts via remoting.  
 
-2.  Open an elevated Powershell Prompt (Right-click Run As Administrator)  
+2. Open an elevated Powershell Prompt (Right-click Run As Administrator)  
 
-3.  At the command prompt, enter:
+3. At the command prompt, enter:
 ```Powershell
 .\kansa.ps1 -Target $env:COMPUTERNAME -ModulePath .\Modules -Verbose  
 ```
-The script should start collecting data or you may see an error about  
-not having Windows Remote Management enabled. If so, do a little  
-searching online, it's easy to turn on. Turn it on and try again. When  
-it finishes running, you'll have a new Output_timestamp subdirectory,  
-with subdirectories for data collected by each module. You can cd into  
-those subdirectories and checkout the data. There are some analysis  
-scripts in the Analysis directory, but many of those won't make sense  
-on a collection of data from a single host. Kansa was written for  
-collection and analysis of data from dozens, hundreds, thousands, tens  
-of thousands of systems.  
+The script should start collecting data or you may see an error about not having Windows Remote Management enabled. If so, do a little searching online, it's easy to turn on. Turn it on and try again. When it finishes running, you'll have a new Output_timestamp subdirectory, with subdirectories for data collected by each module. You can cd into those subdirectories and checkout the data. There are some analysis scripts in the Analysis directory, but many of those won't make sense on a collection of data from a single host. Kansa was written for collection and analysis of data from dozens, hundreds, thousands, tens of thousands of systems.  
 
 ## Running Modules Standalone
-Kansa modules can be run as standalone utilities outside of the Kansa  
-framework. Why might you want to do this? Consider netstat -naob, the  
-output of the command line utility is ugly and doesn't easily lend  
-itself to analysis. Running  
+Kansa modules can be run as standalone utilities outside of the Kansa framework. Why might you want to do this? Consider netstat -naob, the output of the command line utility is ugly and doesn't easily lend itself to analysis. Running  
 ```Powershell
 Modules\Net\Get-Netstat.ps1
 ```
-as a standalone script will call netstat -naob, but it will return  
-Powershell objects in an easy to read, easy to analyze format. You can  
-easily convert its output to CSV, TSV or XML using normal Powershell  
+as a standalone script will call netstat -naob, but it will return Powershell objects in an easy to read, easy to analyze format. You can easily convert its output to CSV, TSV or XML using normal Powershell  
 cmdlets. Here's an example:  
 ```Powershell
 .\Get-Netstat.ps1 | ConvertTo-CSV -Delimiter "`t" -NoTypeInformation | % { $_ -replace "`"" } | Set-Content netstat.tsv
 ```
-the result of the above will be a file called netstat.tsv containing  
-unquoted, tab separate values for netstat -naob's ouput.
+the result of the above will be a file called netstat.tsv containing unquoted, tab separate values for netstat -naob's ouput.
 
 ## Expanded use cases
 Over the past few years, additional output types have been added to Kansa, and several modules have been added or expanded.
@@ -91,7 +63,7 @@ A quick tutorial on setting up Splunk to receive data from Kansa is available he
 ### Enhanced Windows Event Log retrieval
 ```.\Modules\Log\Get-LogWinEvent``` has been modified to allow the user to specify multiple parameters to allow for greater filtering, as well as enhanced parsing of the message body, which is handy if the destination is a log aggregator.
 
-Due to the way in which Kansa parses module names and accompanying parameters, the parameter passed to ```Get-LogWinEvent``` is encodes 3 data points in to one pseudo parameter - the log name(s), how many days back the user wishes to search, and the event IDs the user wishes to filter on. **Only the log name(s) are mandatory***
+Due to the way in which Kansa parses module names and accompanying parameters, the parameter passed to ```Get-LogWinEvent``` encodes 3 data points in to one pseudo parameter - the log name(s), how many days back the user wishes to search, and the event IDs the user wishes to filter on. **Only the log name(s) are mandatory***
 
 In Modules.conf, you can specify the parameter(s) for Get-LogWinEvent as such:
 ```Log\Get-LogWinEvent.ps1 Security|Application|System-7-4624|1003|1014```

From ff6c50e65295a7373a479b2b57a69dcf19498db8 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:42:06 -0500
Subject: [PATCH 09/18] Create Install-PowerForensics.ps1

---
 Modules/Forensics/Install-PowerForensics.ps1 | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 Modules/Forensics/Install-PowerForensics.ps1

diff --git a/Modules/Forensics/Install-PowerForensics.ps1 b/Modules/Forensics/Install-PowerForensics.ps1
new file mode 100644
index 00000000..b8274a15
--- /dev/null
+++ b/Modules/Forensics/Install-PowerForensics.ps1
@@ -0,0 +1,8 @@
+$EncodedCompressedFile = '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'
+$DeflatedStream = New-Object IO.Compression.DeflateStream([IO.MemoryStream][Convert]::FromBase64String($EncodedCompressedFile),[IO.Compression.CompressionMode]::Decompress)
+$UncompressedFileBytes = New-Object Byte[](161280)
+$DeflatedStream.Read($UncompressedFileBytes, 0, 161280) | Out-Null
+$null = [Reflection.Assembly]::Load($UncompressedFileBytes)
+
+$Assembly=([System.AppDomain]::CurrentDomain.GetAssemblies()|? FullName -Match "PowerForensics")[0]
+Import-Module -Assembly $Assembly

From aed4eee07bb5f4d7701f23147efae3cd1b76bfda Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:42:51 -0500
Subject: [PATCH 10/18] Create Get-ForAlternateDataStreams.ps1

---
 .../Forensics/Get-ForAlternateDataStreams.ps1 | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 Modules/Forensics/Get-ForAlternateDataStreams.ps1

diff --git a/Modules/Forensics/Get-ForAlternateDataStreams.ps1 b/Modules/Forensics/Get-ForAlternateDataStreams.ps1
new file mode 100644
index 00000000..0e4e586f
--- /dev/null
+++ b/Modules/Forensics/Get-ForAlternateDataStreams.ps1
@@ -0,0 +1,43 @@
+<# 
+.SYNOPSIS
+    Get-ForAlternateDataStream is a wrapper for Get-ForensicAlternateDataStream. Get-ForAlternateDataStream parses the Master File Table 
+    and returns AlternateDataStream objects for files that contain more than one $DATA attribute.
+
+    NTFS stores file contents in $DATA attributes. The file system allows a single file to maintain multiple $DATA attributes. When a file 
+    has more than one $DATA attribute the additional attributes are referred to as "Alternate Data Streams".
+
+.PARAMETER VolumeName
+    Specifies the name of the volume or logical partition.
+
+    Enter the volume name in one of the following formats: \\.\C:, C:, or C.
+    Defaults to \\.\C:
+
+.PARAMETER Path
+    The path of a file that should be checked for alternate data streams.
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+[cmdletbinding(DefaultParameterSetName='ByVolume')]
+Param(
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [ValidatePattern('^(\\\\\.\\)?([A-Za-z]:)$')]
+    [string]$VolumeName = '\\.\C:',
+
+    [Parameter(Mandatory, ParameterSetName = 'ByPath')]
+    [Alias('FullName')]
+    [string]$Path
+)
+
+begin{}
+
+process{
+    if($PSCmdlet.ParameterSetName -eq 'ByVolume'){
+        Get-ForensicAlternateDataStream -VolumeName $VolumeName
+    }
+    else{
+        Get-ForensicAlternateDataStream -Path $Path
+    }
+}

From 0b8c2e519917823ee4c8f64384e94c6ac26ec92c Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:43:20 -0500
Subject: [PATCH 11/18] Create Get-ForAttrDef.ps1

---
 Modules/Forensics/Get-ForAttrDef.ps1 | 42 ++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 Modules/Forensics/Get-ForAttrDef.ps1

diff --git a/Modules/Forensics/Get-ForAttrDef.ps1 b/Modules/Forensics/Get-ForAttrDef.ps1
new file mode 100644
index 00000000..cd7cf0c4
--- /dev/null
+++ b/Modules/Forensics/Get-ForAttrDef.ps1
@@ -0,0 +1,42 @@
+<# 
+.SYNOPSIS
+    Get-ForAttrDef is a wrapper for Get-ForensicAttrDef. Get-ForAttrDef parses the $AttrDef file on the specified volume 
+    and returns information about all MFT file attributes usable in the volume.
+
+    By default, the cmdlet parses the $AttrDef file on the C:\ drive. To change the target drive, use the VolumeName 
+    parameter or use the Path parameter to specify an exported $AttrDef file.
+
+.PARAMETER VolumeName
+    Specifies the name of the volume or logical partition.
+
+    Enter the volume name in one of the following formats: \\.\C:, C:, or C.
+    Defaults to \\.\C:
+
+.PARAMETER Path
+    The path to the desired MFT.
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+[cmdletbinding(DefaultParameterSetName='ByVolume')]
+Param(
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [ValidatePattern('^(\\\\\.\\)?([A-Za-z]:)$')]
+    [string]$VolumeName = '\\.\C:',
+
+    [Parameter(Mandatory, ParameterSetName = 'ByPath', ValueFromPipelineByPropertyName = $true)]
+    [string]$Path
+)
+
+begin{}
+
+process{
+    if($PSCmdlet.ParameterSetName -eq 'ByVolume'){
+        Get-ForensicAttrDef -VolumeName $VolumeName
+    }
+    else{
+        Get-ForensicAttrDef -Path $Path
+    }
+}

From 374961c96aacd059ba13a4f5ca3d3fb823aa30c4 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:44:06 -0500
Subject: [PATCH 12/18] Create Get-ForFileRecord.ps1

---
 Modules/Forensics/Get-ForFileRecord.ps1 | 53 +++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 Modules/Forensics/Get-ForFileRecord.ps1

diff --git a/Modules/Forensics/Get-ForFileRecord.ps1 b/Modules/Forensics/Get-ForFileRecord.ps1
new file mode 100644
index 00000000..6a6d0a24
--- /dev/null
+++ b/Modules/Forensics/Get-ForFileRecord.ps1
@@ -0,0 +1,53 @@
+<# 
+.SYNOPSIS
+    Get-ForFileRecord is a wrapper for Get-ForensicFileRecord. Get-ForFileRecord parses the $MFT file 
+    and returns an array of FileRecord entries.
+
+    By default, this cmdlet parses the $MFT file on the C:\ drive. To change the target drive, 
+    use the VolumeName parameter or use the Path parameter to specify an exported $MFT file.
+
+.PARAMETER VolumeName
+    Specifies the name of the volume or logical partition.
+
+    Enter the volume name in one of the following formats: \\.\C:, C:, or C.
+    Defaults to \\.\C:
+
+.PARAMETER Index
+    Specifies the index of the file record in the MFT. 
+
+.PARAMETER Path
+    The path to the MFT; could be on a volume different from the default.
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+[cmdletbinding(DefaultParameterSetName='ByVolume')]
+Param(
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [ValidatePattern('^(\\\\\.\\)?([A-Za-z]:)$')]
+    [string]$VolumeName = '\\.\C:',
+
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [long]$Index = 0,
+
+    [Parameter(Mandatory, ParameterSetName = 'ByPath')]
+    [string]$Path
+)
+
+begin{}
+
+process{
+    if($PSCmdlet.ParameterSetName -eq 'ByVolume'){
+        if($PSBoundParameters.ContainsKey('Index')){
+            Get-ForensicFileRecord -VolumeName $VolumeName -Index $Index
+        }
+        else{
+            Get-ForensicFileRecord -VolumeName $VolumeName
+        }
+    }
+    else{
+        Get-ForensicFileRecord -Path $Path
+    }
+}

From cefa1e89cbcfcfe582674b619991ffd2b2c2f86e Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:44:37 -0500
Subject: [PATCH 13/18] Create Get-ForFileRecordIndex.ps1

---
 Modules/Forensics/Get-ForFileRecordIndex.ps1 | 24 ++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 Modules/Forensics/Get-ForFileRecordIndex.ps1

diff --git a/Modules/Forensics/Get-ForFileRecordIndex.ps1 b/Modules/Forensics/Get-ForFileRecordIndex.ps1
new file mode 100644
index 00000000..e3d1c9f6
--- /dev/null
+++ b/Modules/Forensics/Get-ForFileRecordIndex.ps1
@@ -0,0 +1,24 @@
+<# 
+.SYNOPSIS
+    Get-ForFileRecordIndex is a wrapper for Get-ForFileRecordIndex. Get-ForFileRecordIndex returns the 
+    Master File Table Record Index Number for the specified file.
+
+.PARAMETER Path
+    The path of a file for which the user wants the MFT record entry for.
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+Param(
+    [Parameter(Mandatory, ParameterSetName = 'ByPath')]
+    [Alias('FullName')]
+    [string]$Path
+)
+
+begin{}
+
+process{
+    Get-ForensicFileRecordIndex -Path $Path
+}

From 48b3e86faae3bb0980ac93da3121ea44d7342cbc Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:45:00 -0500
Subject: [PATCH 14/18] Create Get-ForFileSlack.ps1

---
 Modules/Forensics/Get-ForFileSlack.ps1 | 51 ++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Modules/Forensics/Get-ForFileSlack.ps1

diff --git a/Modules/Forensics/Get-ForFileSlack.ps1 b/Modules/Forensics/Get-ForFileSlack.ps1
new file mode 100644
index 00000000..505b969a
--- /dev/null
+++ b/Modules/Forensics/Get-ForFileSlack.ps1
@@ -0,0 +1,51 @@
+<# 
+.SYNOPSIS
+    Get-ForFileSlack is a wrapper for Get-ForensicFileSlack. Get-ForFileSlack gets 
+    the specified volume's slack space as a byte array.
+
+    "Slack space" is the difference between the true size of a file's contents and 
+    the allocated size of a file on disk.
+
+    When NTFS stores data in a file, the data must be allocated in cluster-sized 
+    chunks (commonly 4096 bytes), which creates slack space.
+
+.PARAMETER VolumeName
+    Specifies the name of the volume or logical partition.
+
+    Enter the volume name in one of the following formats: \\.\C:, C:, or C.
+    Defaults to \\.\C:
+
+.PARAMETER Index
+    Specifies the index number of the file to return slack space for.
+
+.PARAMETER Path
+    The path of the file to return slack space for.
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+[cmdletbinding(DefaultParameterSetName='ByVolume')]
+Param(
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [ValidatePattern('^(\\\\\.\\)?([A-Za-z]:)$')]
+    [string]$VolumeName = '\\.\C:',
+
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [long]$Index = 0,
+
+    [Parameter(ParameterSetName = 'ByPath')]
+    [string]$Path
+)
+
+begin{}
+
+process{
+    if($PSCmdlet.ParameterSetName -eq 'ByVolume'){
+        Get-ForensicFileSlack -VolumeName $VolumeName
+    }
+    else{
+        Get-ForensicFileSlack -Path $Path
+    }
+}

From 0b513f6f3b1953578df65c4c63dac146458d51f4 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:45:27 -0500
Subject: [PATCH 15/18] Create Get-ForMftSlack.ps1

---
 Modules/Forensics/Get-ForMftSlack.ps1 | 51 +++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 Modules/Forensics/Get-ForMftSlack.ps1

diff --git a/Modules/Forensics/Get-ForMftSlack.ps1 b/Modules/Forensics/Get-ForMftSlack.ps1
new file mode 100644
index 00000000..0403a840
--- /dev/null
+++ b/Modules/Forensics/Get-ForMftSlack.ps1
@@ -0,0 +1,51 @@
+<# 
+.SYNOPSIS
+    Get-ForMftSlack is a wrapper for Get-ForensicMftSlack. Get-ForMftSlack 
+    returns a byte array representing the slack space found in Master File 
+    Table (MFT) records.
+
+    Each MFT File Record is 1024 bytes long. When a file record does not 
+    allocate all 1024 bytes, the remaining bytes are considered "slack". 
+    To compute slack space, compare the AllocatedSize and RealSize properties 
+    of a FileRecord object.
+
+.PARAMETER VolumeName
+    Specifies the name of the volume or logical partition.
+
+    Enter the volume name in one of the following formats: \\.\C:, C:, or C.
+    Defaults to \\.\C:
+
+.PARAMETER Index
+    Specifies the index number of the file to return slack space for.
+
+.PARAMETER Path
+    The path of the file to return slack space for.
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+[cmdletbinding(DefaultParameterSetName='ByVolume')]
+Param(
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [ValidatePattern('^(\\\\\.\\)?([A-Za-z]:)$')]
+    [string]$VolumeName = '\\.\C:',
+        
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [long]$Index = 0,
+
+    [Parameter(ParameterSetName = 'ByPath')]
+    [string]$Path
+)
+
+begin{}
+
+process{
+    if($PSCmdlet.ParameterSetName -eq 'ByVolume'){
+        Get-ForensicMftSlack -VolumeName $VolumeName
+    }
+    else{
+        Get-ForensicMftSlack -Path $Path
+    }
+}

From 85a335f8c81b828d99db359f17072f57cdd82ea2 Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 11:46:55 -0500
Subject: [PATCH 16/18] Update Modules.conf

---
 Modules/Modules.conf | 37 ++++++++++++++++++++++---------------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/Modules/Modules.conf b/Modules/Modules.conf
index 6db91a83..cf329b6e 100644
--- a/Modules/Modules.conf
+++ b/Modules/Modules.conf
@@ -3,24 +3,24 @@
 # Get-SecEventLog.ps1 is commented out below because depending on the environment, it can take ages and
 # if centralized logging is enabled, may not be necessary.
 
-Process\Get-PrefetchListing.ps1
+# Process\Get-PrefetchListing.ps1
 # Process\Get-PrefetchFiles.ps1
-Process\Get-WMIRecentApps.ps1
-Net\Get-Netstat.ps1
-Net\Get-DNSCache.ps1
+# Process\Get-WMIRecentApps.ps1
+# Net\Get-Netstat.ps1
+# Net\Get-DNSCache.ps1
 # Net\Get-Arp.ps1
 # Net\Get-SmbSession.ps1
 # Process\Get-Prox.ps1
 # Process\Get-Tasklistv.ps1
 # Process\Get-Handle.ps1
 # Process\Get-RekalPslist.ps1
-Process\Get-ProcsWMI.ps1
+# Process\Get-ProcsWMI.ps1
 # Process\Get-ProcDump.ps1
 # Process\Get-ProcsNModules.ps1
 # Net\Get-NetRoutes.ps1
 # Net\Get-NetIPInterfaces.ps1
 # Net\Get-WMIIETelemetry.ps1
-Log\Get-LogUserAssist.ps1
+# Log\Get-LogUserAssist.ps1
 # Log\Get-LogWinEvent.ps1 Security
 # Log\Get-LogWinEvent.ps1 Microsoft-Windows-Application-Experience/Program-Inventory
 # Log\Get-LogWinEvent.ps1 Microsoft-Windows-Application-Experience/Program-Telemetry
@@ -37,22 +37,22 @@ Log\Get-LogUserAssist.ps1
 # Log\Get-SysmonProcess.ps1
 # Log\Get-SysmonNetwork.ps1 
 # ASEP\Get-SvcAll.ps1
-ASEP\Get-SvcFail.ps1
-ASEP\Get-SvcTrigs.ps1
-ASEP\Get-WMIEvtFilter.ps1
-ASEP\Get-WMIFltConBind.ps1
-ASEP\Get-WMIEvtConsumer.ps1
-ASEP\Get-PSProfiles.ps1
-ASEP\Get-SchedTasks.ps1
+# ASEP\Get-SvcFail.ps1
+# ASEP\Get-SvcTrigs.ps1
+# ASEP\Get-WMIEvtFilter.ps1
+# ASEP\Get-WMIFltConBind.ps1
+# ASEP\Get-WMIEvtConsumer.ps1
+# ASEP\Get-PSProfiles.ps1
+# ASEP\Get-SchedTasks.ps1
 # Disk\Get-TempDirListing.ps1
-Disk\Get-File.ps1 C:\Windows\WindowsUpdate.log
+# Disk\Get-File.ps1 C:\Windows\WindowsUpdate.log
 # Disk\Get-DiskUsage.ps1 C:\Users
 # Disk\Get-FileHashes.ps1 MD5,C:\Users
 # Disk\Get-FilesByHash.ps1 BF93A2F9901E9B3DFCA8A7982F4A9868,MD5,C:\Windows\System32
 # Disk\Get-WebrootListing.ps1
 # Disk\Get-FilesByHashes.ps1
 # Disk\Get-IOCsByPath.ps1
-Config\Get-LocalAdmins.ps1
+# Config\Get-LocalAdmins.ps1
 # Config\Get-CertStore.ps1
 # Config\Get-AMHealthStatus.ps1
 # Config\Get-AMInfectionStatus.ps1
@@ -65,6 +65,13 @@ Config\Get-LocalAdmins.ps1
 # Config\Get-SharePermissions.ps1
 # Config\Get-ClrVersion.ps1
 
+## Forensics modules
+## If you're going to run any of these modules, you must use Forensics\Install-PowerForensics
+Forensics\Install-PowerForensics.ps1
+Forensics\Get-AlternateDataStreams.ps1
+Forensics\Get-ForFileRecord.ps1
+
+
 ## Long running jobs go here so they're always last.
 # ASEP\Get-Autorunsc.ps1
 # ASEP\Get-AutorunscDeep.ps1

From f6705c3edd22a4abc488cbae2eb9ad3c063a8caf Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 16:43:37 -0500
Subject: [PATCH 17/18] Create Get-

---
 Modules/Forensics/Get- | 44 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 Modules/Forensics/Get-

diff --git a/Modules/Forensics/Get- b/Modules/Forensics/Get-
new file mode 100644
index 00000000..7875d08c
--- /dev/null
+++ b/Modules/Forensics/Get-
@@ -0,0 +1,44 @@
+<# 
+.SYNOPSIS
+    Get-ForUsnJrnl is a wrapper for Get-ForensicUsnJrnl. Get-ForUsnJrnl cmdlet parses the 
+    $UsnJrnl file's $J data stream to return UsnJrnl entries. If you do not specify a Usn 
+    (Update Sequence Number), it returns all entries in the $UsnJrnl.
+
+    The $UsnJrnl file maintains a record of all file system operations that have occurred. 
+    Because the file is circular, entries are overwritten.
+
+.PARAMETER VolumeName
+    Specifies the name of the volume or logical partition.
+
+    Enter the volume name in one of the following formats: \\.\C:, C:, or C.
+    Defaults to \\.\C:
+
+
+.PARAMETER Usn
+    Specifies the Update Sequence Number
+
+Next line is required by Kansa for proper handling of this script's
+output.
+OUTPUT TSV
+#>
+
+[cmdletbinding(DefaultParameterSetName='ByVolume')]
+Param(
+    [Parameter(ParameterSetName = 'ByVolume')]
+    [ValidatePattern('^(\\\\\.\\)?([A-Za-z]:)$')]
+    [string]$VolumeName = '\\.\C:',
+
+    [Parameter(Mandatory, ParameterSetName = 'ByUsn')]
+    [long]$Usn
+)
+
+begin{}
+
+process{
+    if($PSCmdlet.ParameterSetName -eq 'ByVolume'){
+        Get-ForensicUsnJrnl -VolumeName $VolumeName
+    }
+    else{
+        Get-ForensicUsnJrnl -Usn $Usn
+    }
+}

From 61ea7ffff6dee5a290a2ce0bdcc3c5778eefa73d Mon Sep 17 00:00:00 2001
From: Dallas Moore <Dallas.moore21@gmail.com>
Date: Wed, 19 Aug 2020 16:47:15 -0500
Subject: [PATCH 18/18] Rename Get- to Get-ForUsnJrnl.ps1

---
 Modules/Forensics/{Get- => Get-ForUsnJrnl.ps1} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename Modules/Forensics/{Get- => Get-ForUsnJrnl.ps1} (100%)

diff --git a/Modules/Forensics/Get- b/Modules/Forensics/Get-ForUsnJrnl.ps1
similarity index 100%
rename from Modules/Forensics/Get-
rename to Modules/Forensics/Get-ForUsnJrnl.ps1